/*	$OpenBSD: vs_refresh.c,v 1.22 2016/01/30 21:31:08 martijn Exp $	*/

/*-

 * Copyright (c) 1992, 1993, 1994

 *	The Regents of the University of California.  All rights reserved.

 * Copyright (c) 1992, 1993, 1994, 1995, 1996

 *	Keith Bostic.  All rights reserved.

 *

 * See the LICENSE file for redistribution information.

 */

#include "config.h"

#include <sys/types.h>

#include <sys/queue.h>

#include <sys/time.h>

#include <bitstring.h>

#include <ctype.h>

#include <libgen.h>

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "../common/common.h"

#include "vi.h"

#define	UPDATE_CURSOR	0x01			/* Update the cursor. */

#define	UPDATE_SCREEN	0x02			/* Flush to screen. */

static void	vs_modeline(SCR *);

static int	vs_paint(SCR *, u_int);

/*

 * v_repaint --

 *	Repaint selected lines from the screen.

 *

 * PUBLIC: int vs_repaint(SCR *, EVENT *);

 */

int

vs_repaint(SCR *sp, EVENT *evp)

{

	SMAP *smp;

	}

}

/*

 * vs_refresh --

 *	Refresh all screens.

 *

 * PUBLIC: int vs_refresh(SCR *, int);

 */

int

vs_refresh(SCR *sp, int forcepaint)

{

	GS *gp;

	SCR *tsp;

	int need_refresh;

	u_int priv_paint, pub_paint;

	/*

	 * 1: Refresh the screen.

	 *

	 * If SC_SCR_REDRAW is set in the current screen, repaint everything

	 * that we can find, including status lines.

	 */

	/*

	 * 2: Related or dirtied screens, or screens with messages.

	 *

	 * If related screens share a view into a file, they may have been

	 * modified as well.  Refresh any screens that aren't exiting that

	 * have paint or dirty bits set.  Always update their screens, we

	 * are not likely to get another chance.  Finally, if we refresh any

	 * screens other than the current one, the cursor will be trashed.

	 */

	pub_paint = SC_SCR_REFORMAT | SC_SCR_REDRAW;

	priv_paint = VIP_CUR_INVALID | VIP_N_REFRESH;

		}

	/*

	 * 3: Refresh the current screen.

	 *

	 * Always refresh the current screen, it may be a cursor movement.

	 * Also, always do it last -- that way, SC_SCR_REDRAW can be set

	 * in the current screen only, and the screen won't flash.

	 */

	/*

	 * 4: Paint any missing status lines.

	 *

	 * XXX

	 * This is fairly evil.  Status lines are written using the vi message

	 * mechanism, since we have no idea how long they are.  Since we may be

	 * painting screens other than the current one, we don't want to make

	 * the user wait.  We depend heavily on there not being any other lines

	 * currently waiting to be displayed and the message truncation code in

	 * the msgq_status routine working.

	 *

	 * And, finally, if we updated any status lines, make sure the cursor

	 * gets back to where it belongs.

	 */

	need_refresh = 0;

			need_refresh = 1;

		}

	/*

	 * A side-effect of refreshing the screen is that it's now ready

	 * for everything else, i.e. messages.

	 */

}

/*

 * vs_paint --

 *	This is the guts of the vi curses screen code.  The idea is that

 *	the SCR structure passed in contains the new coordinates of the

 *	screen.  What makes this hard is that we don't know how big

 *	characters are, doing input can put the cursor in illegal places,

 *	and we're frantically trying to avoid repainting unless it's

 *	absolutely necessary.  If you change this code, you'd better know

 *	what you're doing.  It's subtle and quick to anger.

 */

static int

vs_paint(SCR *sp, u_int flags)

{

	GS *gp;

	VI_PRIVATE *vip;

#define	 LNO	sp->lno			/* Current file line. */

#define	OLNO	vip->olno		/* Remembered file line. */

#define	 CNO	sp->cno			/* Current file column. */

#define	OCNO	vip->ocno		/* Remembered file column. */

#define	SCNO	vip->sc_col		/* Current screen column. */

	didpaint = leftright_warp = 0;

	/*

	 * 5: Reformat the lines.

	 *

	 * If the lines themselves have changed (:set list, for example),

	 * fill in the map from scratch.  Adjust the screen that's being

	 * displayed if the leftright flag is set.

	 */

		/* Invalidate the line size cache. */

		/* Toss vs_line() cached information. */

		}

		} else {

			}

		}

	}

	/*

	 * 6: Line movement.

	 *

	 * Line changes can cause the top line to change as well.  As

	 * before, if the movement is large, the screen is repainted.

	 *

	 * 6a: Small screens.

	 *

	 * Users can use the window, w300, w1200 and w9600 options to make

	 * the screen artificially small.  The behavior of these options

	 * in the historic vi wasn't all that consistent, and, in fact, it

	 * was never documented how various screen movements affected the

	 * screen size.  Generally, one of three things would happen:

	 *	1: The screen would expand in size, showing the line

	 *	2: The screen would scroll, showing the line

	 *	3: The screen would compress to its smallest size and

	 *		repaint.

	 * In general, scrolling didn't cause compression (200^D was handled

	 * the same as ^D), movement to a specific line would (:N where N

	 * was 1 line below the screen caused a screen compress), and cursor

	 * movement would scroll if it was 11 lines or less, and compress if

	 * it was more than 11 lines.  (And, no, I have no idea where the 11

	 * comes from.)

	 *

	 * What we do is try and figure out if the line is less than half of

	 * a full screen away.  If it is, we expand the screen if there's

	 * room, and then scroll as necessary.  The alternative is to compress

	 * and repaint.

	 *

	 * !!!

	 * This code is a special case from beginning to end.  Unfortunately,

	 * home modems are still slow enough that it's worth having.

	 *

	 * XXX

	 * If the line a really long one, i.e. part of the line is on the

	 * screen but the column offset is not, we'll end up in the adjust

	 * code, when we should probably have compressed the screen.

	 */

				}

			else

				goto small_fill;

				}

			else {

				}

			}

		}

	}

	/*

	 * 6b: Line down, or current screen.

	 */

		/* Current screen. */

			goto adjust;

			goto top;

			goto middle;

		/*

		 * If less than half a screen above the line, scroll down

		 * until the line is on the screen.

		 */

			goto adjust;

		}

		goto bottom;

	}

	/*

	 * 6c: If not on the current screen, may request center or top.

	 */

		goto top;

		goto middle;

	/*

	 * 6d: Line up.

	 */

		/*

		 * If less than half a screen below the line, scroll up until

		 * the line is the first line on the screen.  Special check so

		 * that if the screen has been emptied, we refill it.

		 */

			goto adjust;

		}

		/*

		 * If less than a half screen from the bottom of the file,

		 * put the last line of the file on the bottom of the screen.

		 */

		}

		/* It's not close, just put the line in the middle. */

		goto middle;

	}

	/*

	 * If less than half a screen from the top of the file, put the first

	 * line of the file at the top of the screen.  Otherwise, put the line

	 * in the middle of the screen.

	 */

	} else

	if (0) {

	}

	/*

	 * At this point we know part of the line is on the screen.  Since

	 * scrolling is done using logical lines, not physical, all of the

	 * line may not be on the screen.  While that's not necessarily bad,

	 * if the part the cursor is on isn't there, we're going to lose.

	 * This can be tricky; if the line covers the entire screen, lno

	 * may be the same as both ends of the map, that's why we test BOTH

	 * the top and the bottom of the map.  This isn't a problem for

	 * left-right scrolling, the cursor movement code handles the problem.

	 *

	 * There's a performance issue here if editing *really* long lines.

	 * This gets to the right spot by scrolling, and, in a binary, by

	 * scrolling hundreds of lines.  If the adjustment looks like it's

	 * going to be a serious problem, refill the screen and repaint.

	 */

		}

		}

	}

	/*

	 * If the screen needs to be repainted, skip cursor optimization.

	 * However, in the code above we skipped leftright scrolling on

	 * the grounds that the cursor code would handle it.  Make sure

	 * the right screen is up.

	 */

			goto slow;

		goto paint;

	}

	/*

	 * 7: Cursor movements (current screen only).

	 */

		goto number;

	/*

	 * Decide cursor position.  If the line has changed, the cursor has

	 * moved over a tab, or don't know where the cursor was, reparse the

	 * line.  Otherwise, we've just moved over fixed-width characters,

	 * and can calculate the left/right scrolling and cursor movement

	 * without reparsing the line.  Note that we don't know which (if any)

	 * of the characters between the old and new cursor positions changed.

	 *

	 * XXX

	 * With some work, it should be possible to handle tabs quickly, at

	 * least in obvious situations, like moving right and encountering

	 * a tab, without reparsing the whole line.

	 *

	 * If the line we're working with has changed, reread it..

	 */

		goto slow;

	/* Otherwise, if nothing's changed, ignore the cursor. */

		goto fast;

	/*

	 * Get the current line.  If this fails, we either have an empty

	 * file and can just repaint, or there's a real problem.  This

	 * isn't a performance issue because there aren't any ways to get

	 * here repeatedly.

	 */

			goto slow;

	}

#ifdef DEBUG

	/* Sanity checking. */

	if (CNO >= len && len != 0) {

		msgq(sp, M_ERR, "Error: %s/%d: cno (%u) >= len (%u)",

		     basename(__FILE__), __LINE__, CNO, len);

		return (1);

	}

#endif

	/*

	 * The basic scheme here is to look at the characters in between

	 * the old and new positions and decide how big they are on the

	 * screen, and therefore, how many screen positions to move.

	 */

		/*

		 * 7a: Cursor moved left.

		 *

		 * Point to the old character.  The old cursor position can

		 * be past EOL if, for example, we just deleted the rest of

		 * the line.  In this case, since we don't know the width of

		 * the characters we traversed, we have to do it slowly.

		 */

			goto slow;

		/*

		 * Quick sanity check -- it's hard to figure out exactly when

		 * we cross a screen boundary as we do in the cursor right

		 * movement.  If cnt is so large that we're going to cross the

		 * boundary no matter what, stop now.

		 */

			goto slow;

		/*

		 * Count up the widths of the characters.  If it's a tab

		 * character, go do it the slow way.

		 */

				goto slow;

		/*

		 * Decrement the screen cursor by the total width of the

		 * characters minus 1.

		 */

		/*

		 * If we're moving left, and there's a wide character in the

		 * current position, go to the end of the character.

		 */

		/*

		 * If the new column moved us off of the current logical line,

		 * calculate a new one.  If doing leftright scrolling, we've

		 * moved off of the current screen, as well.

		 */

			goto slow;

		/*

		 * 7b: Cursor moved right.

		 *

		 * Point to the first character to the right.

		 */

		/*

		 * Count up the widths of the characters.  If it's a tab

		 * character, go do it the slow way.  If we cross a

		 * screen boundary, we can quit.

		 */

				goto slow;

				break;

		}

		/*

		 * Increment the screen cursor by the total width of the

		 * characters.

		 */

		/* See screen change comment in section 6a. */

			goto slow;

	}

	/*

	 * 7c: Fast cursor update.

	 *

	 * We have the current column, retrieve the current row.

	 */

	/*

	 * 7d: Slow cursor update.

	 *

	 * Walk through the map and find the current line.

	 */

	/*

	 * 7e: Leftright scrolling adjustment.

	 *

	 * If doing left-right scrolling and the cursor movement has changed

	 * the displayed screen, scroll the screen left or right, unless we're

	 * updating the info line in which case we just scroll that one line.

	 * We adjust the offset up or down until we have a window that covers

	 * the current column, making sure that we adjust differently for the

	 * first screen as compared to subsequent ones.

	 */

		/*

		 * Get the screen column for this character, and correct

		 * for the number option offset.

		 */

		/* Adjust the window towards the beginning of the line. */

			do {

				else {

					off = 0;

				}

			goto shifted;

		}

		/* Adjust the window towards the end of the line. */

			do {

shifted:		/* Fill in screen map with the new offset. */

			else {

				leftright_warp = 1;

			}

			goto paint;

		}

		/*

		 * We may have jumped here to adjust a leftright screen because

		 * redraw was set.  If so, we have to paint the entire screen.

		 */

			goto paint;

	}

	/*

	 * Update the screen lines for this particular file line until we

	 * have a new screen cursor position.

	 */

		}

	}

	goto done_cursor;

	/*

	 * 8: Repaint the entire screen.

	 *

	 * Lost big, do what you have to do.  We flush the cache, since

	 * SC_SCR_REDRAW gets set when the screen isn't worth fixing, and

	 * it's simpler to repaint.  So, don't trust anything that we

	 * think we know about it.

	 */

	}

	/*

	 * If it's a small screen and we're redrawing, clear the unused lines,

	 * ex may have overwritten them.

	 */

		}

done_cursor:

	/*

	 * Sanity checking.  When the repainting code messes up, the usual

	 * result is we don't repaint the cursor and so sc_smap will be

	 * NULL.  If we're debugging, die, otherwise restart from scratch.

	 */

#ifdef DEBUG

	if (vip->sc_smap == NULL)

		abort();

#else

	}

#endif

	/*

	 * 9: Set the remembered cursor values.

	 */

	/*

	 * 10: Repaint the line numbers.

	 *

	 * If O_NUMBER is set and the VIP_N_RENUMBER bit is set, and we

	 * didn't repaint the screen, repaint all of the line numbers,

	 * they've changed.

	 */

	/*

	 * 11: Update the mode line, position the cursor, and flush changes.

	 *

	 * If we warped the screen, we have to refresh everything.

	 */

		/*

		 * XXX

		 * If the screen shifted, we recalculate the "most favorite"

		 * cursor position.  Vi won't know that we've warped the

		 * screen, so it's going to have a wrong idea about where the

		 * cursor should be.  This is vi's problem, and fixing it here

		 * is a gross layering violation.

		 */

	}

	/* 12: Clear the flags that are handled by this routine. */

	    VIP_N_EX_PAINT | VIP_N_REFRESH | VIP_N_RENUMBER | VIP_S_MODELINE);

#undef	 LNO

#undef	OLNO

#undef	 CNO

#undef	OCNO

#undef	SCNO

}

/*

 * vs_modeline --

 *	Update the mode line.

 */

static void

vs_modeline(SCR *sp)

{

	static char * const modes[] = {

		"Append",			/* SM_APPEND */

		"Change",			/* SM_CHANGE */

		"Command",			/* SM_COMMAND */

		"Insert",			/* SM_INSERT */

		"Replace",			/* SM_REPLACE */

	};

	GS *gp;

	const char *t = NULL;

	int ellipsis;

	/*

	 * It's possible that this routine will be called after sp->frp

	 * has been set to NULL by file_end().  We return immediately

	 * to avoid a SEGV.

	 */

	/*

	 * We put down the file name, the ruler, the mode and the dirty flag.

	 * If there's not enough room, there's not enough room, we don't play

	 * any special games.  We try to put the ruler in the middle and the

	 * mode and dirty flag at the end.

	 *

	 * !!!

	 * Leave the last character blank, in case it's a really dumb terminal

	 * with hardware scroll.  Second, don't paint the last character in the

	 * screen, SunOS 4.1.1 and Ultrix 4.2 curses won't let you.

	 *

	 * Move to the last line on the screen.

	 */

	/* If more than one screen in the display, show the file name. */

	curlen = 0;

			}

				ellipsis = 3;

				}

				break;

			}

		}

		}

	}

	/* Clear the rest of the line. */

	/*

	 * Display the ruler.  If we're not at the midpoint yet, move there.

	 * Otherwise, add in two extra spaces.

	 *

	 * Adjust the current column for the fact that the editor uses it as

	 * a zero-based number.

	 *

	 * XXX

	 * Assume that numbers, commas, and spaces only take up a single

	 * column on the screen.

	 */

		}

	}

	/*

	 * Display the mode and the modified flag, as close to the end of the

	 * line as possible, but guaranteeing at least two spaces between the

	 * ruler and the modified flag.

	 */

#define	MODESIZE	9

	endpoint = cols;

	}

		}

	}

}