/*	$OpenBSD: display.c,v 1.48 2017/07/06 19:27:37 schwarze Exp $	*/

/* This file is in the public domain. */

/*

 * The functions in this file handle redisplay. The

 * redisplay system knows almost nothing about the editing

 * process; the editing functions do, however, set some

 * hints to eliminate a lot of the grinding. There is more

 * that can be done; the "vtputc" interface is a real

 * pig.

 */

#include <sys/queue.h>

#include <ctype.h>

#include <signal.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <term.h>

#include "def.h"

#include "kbd.h"

/*

 * A video structure always holds

 * an array of characters whose length is equal to

 * the longest line possible. v_text is allocated

 * dynamically to fit the screen width.

 */

struct video {

	short	v_hash;		/* Hash code, for compares.	 */

	short	v_flag;		/* Flag word.			 */

	short	v_color;	/* Color of the line.		 */

	int	v_cost;		/* Cost of display.		 */

	char	*v_text;	/* The actual characters.	 */

};

#define VFCHG	0x0001			/* Changed.			 */

#define VFHBAD	0x0002			/* Hash and cost are bad.	 */

#define VFEXT	0x0004			/* extended line (beond ncol)	 */

/*

 * SCORE structures hold the optimal

 * trace trajectory, and the cost of redisplay, when

 * the dynamic programming redisplay code is used.

 */

struct score {

	int	s_itrace;	/* "i" index for track back.	 */

	int	s_jtrace;	/* "j" index for trace back.	 */

	int	s_cost;		/* Display cost.		 */

};

void	vtmove(int, int);

void	vtputc(int);

void	vtpute(int);

int	vtputs(const char *);

void	vteeol(void);

void	updext(int, int);

void	modeline(struct mgwin *, int);

void	setscores(int, int);

void	traceback(int, int, int, int);

void	ucopy(struct video *, struct video *);

void	uline(int, struct video *, struct video *);

void	hash(struct video *);

int	sgarbf = TRUE;		/* TRUE if screen is garbage.	 */

int	vtrow = HUGE;		/* Virtual cursor row.		 */

int	vtcol = HUGE;		/* Virtual cursor column.	 */

int	tthue = CNONE;		/* Current color.		 */

int	ttrow = HUGE;		/* Physical cursor row.		 */

int	ttcol = HUGE;		/* Physical cursor column.	 */

int	tttop = HUGE;		/* Top of scroll region.	 */

int	ttbot = HUGE;		/* Bottom of scroll region.	 */

int	lbound = 0;		/* leftmost bound of the current */

				/* line being displayed		 */

struct video	**vscreen;		/* Edge vector, virtual.	 */

struct video	**pscreen;		/* Edge vector, physical.	 */

struct video	 *video;		/* Actual screen data.		 */

struct video	  blanks;		/* Blank line image.		 */

/*

 * This matrix is written as an array because

 * we do funny things in the "setscores" routine, which

 * is very compute intensive, to make the subscripts go away.

 * It would be "SCORE	score[NROW][NROW]" in old speak.

 * Look at "setscores" to understand what is up.

 */

struct score *score;			/* [NROW * NROW] */

static int	 linenos = TRUE;

static int	 colnos = FALSE;

/* Is macro recording enabled? */

extern int macrodef;

/* Is working directory global? */

extern int globalwd;

/*

 * Since we don't have variables (we probably should) these are command

 * processors for changing the values of mode flags.

 */

/* ARGSUSED */

int

linenotoggle(int f, int n)

{

	else

}

/* ARGSUSED */

int

colnotoggle(int f, int n)

{

	else

}

/*

 * Reinit the display data structures, this is called when the terminal

 * size changes.

 */

int

vtresize(int force, int newrow, int newcol)

{

	int	 i;

	int	 rowchanged, colchanged;

	static	 int first_run = 1;

	struct video	*vp;

#define TRYREALLOC(a, n) do {					\

		void *tmp;					\

		if ((tmp = realloc((a), (n))) == NULL) {	\

			panic("out of memory in display code");	\

		}						\

		(a) = tmp;					\

	} while (0)

#define TRYREALLOCARRAY(a, n, m) do {				\

		void *tmp;					\

		if ((tmp = reallocarray((a), (n), (m))) == NULL) {\

			panic("out of memory in display code");	\

		}						\

		(a) = tmp;					\

	} while (0)

	/* No update needed */

		int vidstart;

		/*

		 * This is not pretty.

		 */

		else

		/*

		 * We're shrinking, free some internal data.

		 */

			}

		}

		/*

		 * Zero-out the entries we just allocated.

		 */

		/*

		 * Reinitialize vscreen and pscreen arrays completely.

		 */

		vp = &video[0];

		}

	}

	}

}

#undef TRYREALLOC

#undef TRYREALLOCARRAY

/*

 * Initialize the data structures used

 * by the display code. The edge vectors used

 * to access the screens are set up. The operating

 * system's terminal I/O channel is set up. Fill the

 * "blanks" array with ASCII blanks. The rest is done

 * at compile time. The original window is marked

 * as needing full update, and the physical screen

 * is marked as garbage, so all the right stuff happens

 * on the first call to redisplay.

 */

void

vtinit(void)

{

	int	i;

	/*

	 * ttinit called ttresize(), which called vtresize(), so our data

	 * structures are setup correctly.

	 */

}

/*

 * Tidy up the virtual display system

 * in anticipation of a return back to the host

 * operating system. Right now all we do is position

 * the cursor to the last line, erase the line, and

 * close the terminal channel.

 */

void

vttidy(void)

{

}

/*

 * Move the virtual cursor to an origin

 * 0 spot on the virtual display screen. I could

 * store the column as a character pointer to the spot

 * on the line, which would make "vtputc" a little bit

 * more efficient. No checking for errors.

 */

void

vtmove(int row, int col)

{

}

/*

 * Write a character to the virtual display,

 * dealing with long lines and the display of unprintable

 * things like control characters. Also expand tabs every 8

 * columns. This code only puts printing characters into

 * the virtual display image. Special care must be taken when

 * expanding tabs. On a screen whose width is not a multiple

 * of 8, it is possible for the virtual cursor to hit the

 * right margin before the next tab stop is reached. This

 * makes the tab code loop if you are not careful.

 * Three guesses how we found this.

 */

void

vtputc(int c)

{

	struct video	*vp;

#ifdef	NOTAB

	    && !(curbp->b_flag & BFNOTAB)

#endif

	    ) {

	else {

	}

}

/*

 * Put a character to the virtual screen in an extended line.  If we are not

 * yet on left edge, don't print it yet.  Check for overflow on the right

 * margin.

 */

void

vtpute(int c)

{

	struct video *vp;

#ifdef	NOTAB

	    && !(curbp->b_flag & BFNOTAB)

#endif

	    ) {

	}

}

/*

 * Erase from the end of the software cursor to the end of the line on which

 * the software cursor is located. The display routines will decide if a

 * hardware erase to end of line command should be used to display this.

 */

void

vteeol(void)

{

	struct video *vp;

}

/*

 * Make sure that the display is

 * right. This is a three part process. First,

 * scan through all of the windows looking for dirty

 * ones. Check the framing, and refresh the screen.

 * Second, make sure that "currow" and "curcol" are

 * correct for the current window. Third, make the

 * virtual and physical screens the same.

 */

void

update(int modelinecolor)

{

	struct line	*lp;

	struct mgwin	*wp;

	struct video	*vp1;

	struct video	*vp2;

	int	 c, i, j;

	int	 hflag;

	int	 currow, curcol;

	int	 offs, size;

		}

	}

		}

	}

	hflag = FALSE;			/* Not hard. */

		/*

		 * Nothing to be done.

		 */

			continue;

					goto out;

					break;

			}

		}

		/*

		 * Put the middle-line in place.

		 */

				i = 0;

		/*

		 * Find the line.

		 */

			lp = lback(lp);

		}

	out:

			}

			hflag = TRUE;

				}

			}

		}

	}

	}

	curcol = 0;

	i = 0;

#ifdef	NOTAB

		    && !(curbp->b_flag & BFNOTAB)

#endif

			) {

		else {

		}

	}

		/* flag we are extended and changed */

	/*

	 * Make sure no lines need to be de-extended because the cursor is no

	 * longer on them.

	 */

				/* always flag extended lines as changed */

					/* this line no longer is extended */

				}

			}

		}

		/* if garbaged then fix up mode lines */

		/* and onward to the next window */

	}

		}

	}

		}

		offs = 0;			/* Get top match.	*/

				break;

		}

		}

		size = nrow - 1;		/* Get bottom match.	*/

				break;

		}

	}

		}

	}

}

/*

 * Update a saved copy of a line,

 * kept in a video structure. The "vvp" is

 * the one in the "vscreen". The "pvp" is the one

 * in the "pscreen". This is called to make the

 * virtual and physical screens the same when

 * display has done an update.

 */

void

ucopy(struct video *vvp, struct video *pvp)

{

}

/*

 * updext: update the extended line which the cursor is currently on at a

 * column greater than the terminal width. The line will be scrolled right or

 * left to let the user see where the cursor is.

 */

void

updext(int currow, int curcol)

{

	struct line	*lp;			/* pointer to current line */

	int	 j;			/* index into line */

	/*

	 * calculate what column the left bound should be

	 * (force cursor into middle half of screen)

	 */

	/*

	 * scan through the line outputing characters to the virtual screen

	 * once we reach the left edge

	 */

}

/*

 * Update a single line. This routine only

 * uses basic functionality (no insert and delete character,

 * but erase to end of line). The "vvp" points at the video

 * structure for the line on the virtual screen, and the "pvp"

 * is the same for the physical screen. Avoid erase to end of

 * line when updating CMODE color lines, because of the way that

 * reverse video works on most terminals.

 */

void

uline(int row, struct video *vvp, struct video *pvp)

{

	char  *cp1;

	char  *cp2;

	char  *cp3;

	char  *cp4;

	char  *cp5;

	int    nbflag;

#ifdef	STANDOUT_GLITCH

#endif

#ifdef	STANDOUT_GLITCH

		/*

		 * The odd code for magic_cookie_glitch==0 is to avoid

		 * putting the invisible glitch character on the next line.

		 * (Hazeltine executive 80 model 30)

		 */

#else

		cp1 = &vvp->v_text[0];

		cp2 = &vvp->v_text[ncol];

#endif

		}

	}

	}

	nbflag = FALSE;

	cp3 = &vvp->v_text[ncol];	/* Compute right match.  */

	}

	cp5 = cp3;			/* Is erase good?	 */

		/* Alcyon hack */

	}

	/* Alcyon hack */

#ifdef	STANDOUT_GLITCH

#endif

	}

}

/*

 * Redisplay the mode line for the window pointed to by the "wp".

 * This is the only routine that has any idea of how the mode line is

 * formatted. You can change the modeline format by hacking at this

 * routine. Called by "update" any time there is a dirty window.  Note

 * that if STANDOUT_GLITCH is defined, first and last magic_cookie_glitch

 * characters may never be seen.

 */

void

modeline(struct mgwin *wp, int modelinecolor)

{

	int	n, md;

	struct buffer *bp;

	int len;

		else

	}

	n = 5;

	}

			break;

	}

	/* XXX These should eventually move to a real mode */

	}

}

/*

 * Output a string to the mode line, report how long it was.

 */

int

vtputs(const char *s)

{

	int n = 0;

	}

}

/*

 * Compute the hash code for the line pointed to by the "vp".

 * Recompute it if necessary. Also set the approximate redisplay

 * cost. The validity of the hash code is marked by a flag bit.

 * The cost understand the advantages of erase to end of line.

 * Tuned for the VAX by Bob McNamara; better than it used to be on

 * just about any machine.

 */

void

hash(struct video *vp)

{

	int	i, n;

	char   *s;

				break;

	}

}

/*

 * Compute the Insert-Delete

 * cost matrix. The dynamic programming algorithm

 * described by James Gosling is used. This code assumes

 * that the line above the echo line is the last line involved

 * in the scroll region. This is easy to arrange on the VT100

 * because of the scrolling region. The "offs" is the origin 0

 * offset of the first row in the virtual/physical screen that

 * is being updated; the "size" is the length of the chunk of

 * screen being updated. For a full screen update, use offs=0

 * and size=nrow-1.

 *

 * Older versions of this code implemented the score matrix by

 * a two dimensional array of SCORE nodes. This put all kinds of

 * multiply instructions in the code! This version is written to

 * use a linear array and pointers, and contains no multiplication

 * at all. The code has been carefully looked at on the VAX, with

 * only marginal checking on other machines for efficiency. In

 * fact, this has been tuned twice! Bob McNamara tuned it even

 * more for the VAX, which is a big issue for him because of

 * the 66 line X displays.

 *

 * On some machines, replacing the "for (i=1; i<=size; ++i)" with

 * i = 1; do { } while (++i <=size)" will make the code quite a

 * bit better; but it looks ugly.

 */

void

setscores(int offs, int size)

{

	struct score	 *sp;

	struct score	 *sp1;

	struct video	**vp, **pp;

	struct video	**vbase, **pbase;

	int	  tempcost;

	int	  bestcost;

	int	  j, i;

	tempcost = 0;

	}

	tempcost = 0;

	}

		sp = sp1;

		vp = &vbase[1];

				bestcost = tempcost;

			}