minix/commands/elle/eebuff.c

/* ELLE - Copyright 1982, 1984, 1987 by Ken Harrenstien, SRI International
 *	This software is quasi-public; it may be used freely with
 *	like software, but may NOT be sold or made part of licensed
 *	products without permission of the author.
 */

/* EEBUFF	Buffer and Window functions.
 *	Each buffer is an independent SB-string described by a
 *	buffer structure.  All buffer structures are allocated dynamically
 *	and chained together starting from buf_head.
 */

#include "elle.h"

#if FX_FILLMODE
extern int fill_mode;
#endif
#if FX_SKMAC
extern int kdef_mode;
#endif

struct buffer *make_buf(), *find_buf(), *sel_mbuf(), *sel_nbuf();
struct window *make_win();

/* EFUN: "Select Buffer" */
/*	Select old buffer or create a new one.  Defaults to previously
 *	used buffer.
 */
f_selbuffer()
{	register char *ans;
	register struct buffer *b;

	if((b = last_buf) == cur_buf)	/* If default same as current, */
		if(!(b = sel_mbuf(b)))	/* try to pick a more useful one. */
			b = sel_nbuf(cur_buf);

	ans = ask("Select buffer (%s): ",b->b_name);
	if (ans == 0)		       /* he aborted */
		return;
	if (*ans != '\0')		/* Null string => use last buff */
	  {	b = find_buf (ans);	/* Else find/create one */
		if (b == 0)
			b = make_buf (ans);
	  }
	sel_buf(b);
	chkfree(ans);
}

#if FX_SELXBUFFER
/* EFUN: "Select Existing Buffer" (not EMACS) - from IMAGEN config */

static int findstr();

f_selxbuffer()
{	register char *ans;
	register struct buffer *b;

	b = last_buf;			/* This is default */
	ans = ask("Select existing buffer (%s): ", b->b_name);
	if (ans == 0)			/* Aborted */
		return;
	if (*ans != 0)
	  {	for (b = buf_head; b != 0; b = b->b_next)
			if (findstr(ans, b->b_name))
				break;
		if (b == 0)
			ding("That isn't a substring of any buffer name!");
	  }
	chkfree(ans);
	if (b != 0)
	  {	saytoo(" => ");
		sayntoo(b->b_name);
		sel_buf(b);
	  }
}

static int
findstr(str, instr)			/* Find "str" in string "instr" */
register char *str, *instr;
{	register char *sp, *isp;

	while (*instr)
	  {	sp = str;
		isp = instr;
		while (*sp)
			if (*sp++ != *isp++)
				goto next;
		return(1);
next:		++instr;
	  }
	return(0);
}
#endif /*FX_SELXBUFFER*/


/* EFUN: "Kill Buffer"	*/
/*	Kill specified buffer - defaults to current buffer.
 * This code assumes a killed buffer will never be on a window list unless it
 * is pointed to by cur_buf or oth_win->w_buf!!!!
 */
f_kbuffer()
{	register struct buffer *b, *ob;
	register char *ans;

	if((ans = ask("Kill buffer: ")) == 0)
		return;
	if(*ans == 0) b = cur_buf;
	else if(*ans == SP) b = 0;
	else b = find_buf(ans);

	chkfree(ans);
	if(!b)
	  {	ding("No such buffer");
		return;
	  }
#if IMAGEN
	if (b->b_flags & B_PERMANENT)
	  {	ding("Permanent buffer--cannot kill!");
		return;
	  }
	if (b->b_flags & B_MODIFIED)
	  {	if ((ans == ask("Buffer is modified; are you sure? ")) == 0)
			return;
		if(upcase(*ans) != 'Y')
		  {	chkfree(ans);
			return;
		  }
		chkfree(ans);
	  }
#endif /*IMAGEN*/
	if(b == cur_buf || (oth_win && (oth_win->w_buf == b)))
	  {	ob = last_buf;
		do
		  {
			/* If default same as doomed buffer, try to pick
			 * a more useful alternative. */
			if((b == ob) && !(ob = sel_mbuf(b)))
				ob = sel_nbuf(b);

			ans = ask("Killing in-use buffer; select which other buffer (%s): ",
					ob->b_name);
			if(ans == 0) return;
			if(*ans)
			  {	if(*ans == SP) ob = 0;
				else ob = find_buf(ans);
			  }
			chkfree(ans);
			if(!ob)
			  {	ding("No such buffer");
				return;
			  }
		  } while (b == ob);

		/* B is buffer to kill, OB is buffer to replace it with */
		if(oth_win && (oth_win->w_buf == b))
		  {	f_othwind();	/* Select other one */
			chg_buf(ob);	/* Change to new buffer */
			f_othwind();
		  }
		if(cur_buf == b)
			chg_buf(ob);
	  }

	kill_buf(b);			/* Die!!!! */
	if(last_buf == b)
		last_buf = cur_buf;
}

/* EFUN: "List Buffers" */
/*	Display a list of all user buffers.  Internal buffers, whose names
 *	start with a space, are not shown.
 */
f_listbufs()
{
	register struct buffer *b;
	register char *cp;
	register int i;
	struct buffer *tbuf, *savbuf;
	char temp[20];

	/* First must set up special buffer... */
	savbuf = cur_buf;
	chg_buf(tbuf = make_buf(" **SHOW**"));
	e_sputz("Buffers in this ELLE:\n\n");
	for(b = buf_head; b; b = b->b_next)
	  {	cp = b->b_name;
		if(*cp == SP) continue;	/* Ignore internal buffs */
		e_sputz((b->b_flags&B_MODIFIED) ? "* " : "  ");
		e_sputz(cp);			/* Insert buffer name */
		dottoa(temp,ex_blen(b));	/* Get buff-length string */
		if((i = ((FNAMELEN > 14) ? 30 : 20)
			 - strlen(cp) - strlen(temp)) > 0)
			e_insn(SP, i);
		e_sputz(" (");
		e_sputz(temp);
		e_sputz(") ");
		if(cp = b->b_fn)
			e_sputz(cp);
#if IMAGEN
		if (b->b_flags & B_CMODE)
			e_sputz(" (C)");
		else if (b->b_flags & B_TEXTMODE)
			e_sputz(" (Text)");
		else
			e_sputz(" (Fundamental)");
#endif /*IMAGEN*/
		e_putc(LF);
	  }
	mk_showin(tbuf);	/* Show this buffer in temp window */
	chg_buf(savbuf);	/* Return to real current buffer */
	kill_buf(tbuf);
}

/* EFUN: "Buffer Not Modified" */
/*	Mark the current buffer as not modified.
 */
f_bufnotmod()
{
	cur_buf -> b_flags &= ~B_MODIFIED;
	redp(RD_MODE);
}

#if FX_EOLMODE
/* EFUN: "EOL CRLF Mode" (not EMACS) */
/*	Toggle the EOL mode of the current buffer.
**		LF EOL Mode means LF alone is an EOL.
**		CRLF EOL Mode means CRLF together is an EOL.
*/
f_eolmode()
{
	cur_buf->b_flags ^= B_EOLCRLF;		/* Flip this bit */
	say((cur_buf->b_flags & B_EOLCRLF)
		? "EOL Mode is CRLF"		/* If now on */
		: "EOL Mode is LF");		/* If now off */

	redp(RD_WINRES);			/* Redo window for this buf */
}
#endif /*FX_EOLMODE*/

#if FX_GOBEG
/* EFUN: "Goto Beginning" */
f_gobeg()
{	e_gobob();
	ed_setcur();
}
#endif /*FX_GOBEG*/

#if FX_GOEND
/* EFUN: "Goto End" */
f_goend()
{	e_goeob();
	ed_setcur();
}
#endif /*FX_GOEND*/

#if FX_WHATPAGE
/* EFUN: "What Page" */
/*	Extra info added as per earlier ICONOGRAPHICS "What Buffer Position"
** Reports on current position as follows:
**	Dot=<n>, Page <n>  Line <n> (line <n> of <m>)
*/
f_whatpage()
{
	register chroff cnt;
	register int c;
	register int page, line;
	int lineatp;
	char tempstr[12], *dottoa ();

        saynow("Dot=");
        dottoa(tempstr, cur_dot);
        sayntoo(tempstr);

	e_gobob();
	page = line = lineatp = 1;
	for (cnt = cur_dot; --cnt >= 0;)
		if ((c = e_getc()) == LF)
			++line;
		else if (c == FF)
		  {	++page;
			lineatp = line;
		  }

        saytoo(", Page ");
        dottoa(tempstr, (chroff)page);
        saytoo(tempstr);
	saytoo("  Line ");
        dottoa(tempstr, (chroff)(1 + line - lineatp));
        saytoo(tempstr);
	saytoo("  Col ");
        dottoa(tempstr, (chroff)indtion(cur_dot));
        saytoo(tempstr);
	saytoo("  [line ");
	dottoa(tempstr, (chroff)line);
	saytoo(tempstr);
	sayntoo(" of ");		/* Force out while scan rest */

        for(e_gocur(); e_gonl() ; ++line) ;	/* Count lines until EOF */
	c = e_rgetc();			/* Remember what last char is */
        dottoa(tempstr, (chroff)line);
        saytoo(tempstr);
        if (c != LF)		/* Check last char */
            saytoo(" (no EOL at EOF!)");
        sayntoo("]");
	e_gocur();			/* Back to original position */
}
#endif /*FX_WHATPAGE*/

init_buf ()			       /* init buffer stuff */
{
	buf_head = 0;
	lines_buf = cur_buf = make_buf(" **LINES**");	/* For sep_win */
	e_insn('-',scr_wid-2);			/* Fill with dashes */
	last_buf = cur_buf = make_buf ("Main");	/* Make Main buffer */
	init_win();				/* Now can init windows */
}

struct buffer *
make_buf(bname)	       /* create buffer "bname" if it doesn't exist */
char *bname;
{	register struct buffer *b;
	register char *name;

	b = find_buf(name = bname);
	if (b)				/* if it exists already */
		return(b);
	b = (struct buffer *) memalloc(sizeof (struct buffer));
	b -> b_next = buf_head;	       /* link it in */
	buf_head = b;
	b->b_name = strdup(name);	/* Allocate copy of name string */
	b->b_dot = 0;		/* Set dot to beg */
	sb_open(b,(SBSTR *)0);		/* Open buffer with null initial sbstring */
	b->b_fn = 0;
	b->b_flags = 0;
	b->b_mode = cur_mode;	/* Inherit current mode */
	return(b);
}


struct buffer *
find_buf(name)	       /* returns pointer to buffer of that name or 0 */
char *name;
{	register struct buffer *b = buf_head;

	while (b && strcmp(b->b_name, name))
		b = b -> b_next;
	return(b);
}

sel_buf(b)				/* select buffer, saving last */
struct buffer *b;
{
	if(b != cur_buf) last_buf = cur_buf;
	chg_buf(b);
}

chg_buf (newbuf)		       /* change current buffer to newbuf */
struct buffer *newbuf;
{	register struct buffer *obuf, *nbuf;

	if ((nbuf = newbuf) == (obuf = cur_buf))
		return;			/* Do nothing if same buffers */
	obuf->b_dot = cur_dot;
	cur_buf = nbuf;
	cur_mode = nbuf->b_mode;
	e_gosetcur(nbuf->b_dot);	/* Set cur_dot and go there */
	cur_win->w_buf = nbuf;
	cur_win->w_dot = cur_dot;
#if IMAGEN
	cur_win->w_redp = RD_WINRES|RD_REDO;
#else
	cur_win->w_redp = RD_WINRES;	/* Reset flags - do complete update */
#endif /*-IMAGEN*/
	unlk_buf(obuf);			/* Unlock previous buffer if can */
	mark_p = 0;			/* this is lazy */
	redp(RD_MODE|RD_WINRES);
}

/* See if specified buffer belongs to any active window, and
 * if not then get it into an idle, unlocked state; this helps the
 * edit package compact and swap stuff out while it's not being used.
 * Assumes proper state of dot has been stored into b_dot.
 */
unlk_buf(bufp)
struct buffer *bufp;
{	register struct buffer *b;
	register struct window *w;

	b = bufp;
	for(w = win_head; w; w = w->w_next)
		if(b == w->w_buf)
			return;		/* Buffer is actively being shown */
	sb_rewind((SBBUF *)b);		/* Return to idle state */
}

/* SEL_NBUF(buf) - Select next user buffer.  Ignores internal buffers.
 *	Arg of 0 starts at beg of buffer list.  Always returns
 *	a buffer pointer - returns argument (which may be 0)
 *	if found no other user buffers.
 *
 * SEL_MBUF(buf) - Select next modified buffer.
 *	Returns buffer ptr to "next" modified buffer, if any.
 *	Arg of 0 starts at beg of buffer list and scans all of them.
 *	Returns 0 if no other modified buffers exist (unlike SEL_NBUF!)
 *	Ignores internal buffers, whose names start with a space.
 */
/* struct buffer *buf_mptr; */
#if 0
struct buffer *
sel_mbuf(buf)
struct buffer *buf;
{	register struct buffer *b;
	register int sweep;

	sweep = 0;			/* Make 2 sweeps only */
	if(b = buf) b = b->b_next;
	do {
		if(b == 0)		/* Initialize if needed */
			b = buf_head;
		for(; b; b = b->b_next)
			if((b->b_flags & B_MODIFIED) && (*b->b_name != SP))
				return((b == buf) ? 0 : b);
	  } while(sweep++ != 0);
	return(0);
}
#endif /*COMMENT*/

struct buffer *
sel_mbuf(buf)
register struct buffer *buf;
{	register struct buffer *b, *b2;
	b = b2 = sel_nbuf(buf);
	do {	if(b == buf) break;
		if(b->b_flags & B_MODIFIED)
			return(b);
	  } while((b = sel_nbuf(b)) != b2);

	return(0);
}

struct buffer *
sel_nbuf(buf)
register struct buffer *buf;
{	register struct buffer *b;

	b = buf;
	do {
		if(!b || !(b = b->b_next))
			b = buf_head;
		if(*b->b_name != SP)
			break;
	  } while (b != buf);
	return(b);
}


kill_buf(buf)
struct buffer *buf;
{	register struct buffer *b, *b1, *bt;

	b = buf;
	b1 = 0;
	for(bt = buf_head; bt && bt != b; bt = bt -> b_next)
		b1 = bt;
	if(bt == 0)
	  {	ring_bell();
		errbarf("No such buffer");	/* Internal error */
		return;
	  }
	if (b1 == 0)
		buf_head = b->b_next;
	else
		b1->b_next = b->b_next;
	sbs_del(sb_close((SBBUF *)b));	/* Close buffer & delete sbstring */
	sb_fdcls(-1);			/* Make sweep for unused FD's */
	if(b->b_fn)
		chkfree(b->b_fn);	/* Flush filename if one */
	chkfree(b->b_name);		/* Flush name */
	chkfree((char *)b);		/* Flush buffer */
}

/* ZAP_BUFFER - Delete all of the buffer, but if it's been modified,
 *	ask first.  Returns 0 if user aborts.
 */
zap_buffer()
{
#if IMAGEN
	extern struct buffer *exec_buf;	/* in e_make.c */

	if(cur_buf != exec_buf && cur_buf -> b_flags & B_MODIFIED)
#else
	if(cur_buf -> b_flags & B_MODIFIED)
#endif /*-IMAGEN*/
		if(ask_kbuf(cur_buf) <= 0)
			return(0);		/* Aborted */
	ed_reset();		/* This takes care of redisplay too */
	mark_p = 0;
#if IMAGEN
	cur_buf->b_flags &= ~B_BACKEDUP; /* Clear backed-up flag */
#endif
	return(1);
}



/* ASK_KBUF - Ask user "are you sure?" before killing a buffer.
 *	Returns +1 if user says "yes" - OK to kill.
 *		 0 if user aborts (^G)
 *		-1 if user says "no".
 */
ask_kbuf(buf)
struct buffer *buf;
{	register struct buffer *b;
	register char *s;
	register int ans;

	b = buf;
	s = ask("Buffer %s contains changes - forget them? ", b->b_name);
	if(s == 0) return(0);
	ans = (upcase(*s) == 'Y') ? 1 : -1;
	chkfree(s);
	return(ans);
}

/* Window stuff */

/* Like EMACS, ELLE only provides at most two user windows.
 * The current user window is pointed to by user_win;
 * the "other" one is oth_win.  If oth_win == 0, there is only one user
 * window.
 */

#if FX_2MODEWINDS
int sepmode_p = 0;	/* Set true if separator window is a 2nd mode win */
#endif

/* EFUN: "Two Windows" */
/*	Divide the current window in half, put the current buffer in the
 *	other window, and go to the new window.
 */
f_2winds()
{	register int h, t;
	register struct window *w;

	if (oth_win)
	  {
#if !(IMAGEN)
		ding("Already 2 windows");
#endif /*-IMAGEN*/
		return;
	  }
	w = cur_win;
	d_fixcur();			/* Stabilize current window */
	h = (w->w_ht) / 2;
	t = w->w_pos + h;		/* Pos of dividing window */
	sep_win = make_win(t, 1, lines_buf);
					/* assume using dashes to separate */
	oth_win = make_win(t + 1, w->w_ht - (h + 1), cur_buf);
					/* Other window has balance */
#if FX_SOWIND
	oth_win->w_flags |= cur_win->w_flags&W_STANDOUT;
	sep_win->w_flags |= mode_win->w_flags&W_STANDOUT;
#endif
#if FX_2MODEWINDS
	chk2modws();			/* Update 2-mode-wind status */
#endif
	w->w_ht = h;			/* Decrease current window to half */

	/* Minimize redisplay by moving each window's dot into
	 * a currently displayed area */
	if(cur_dot < (oth_win->w_topldot = scr[t+1]->sl_boff))
		oth_win->w_dot = oth_win->w_topldot;	/* Adj bottom win */
	else					/* Adjust top window */
	  {	oth_win->w_dot = cur_dot;	/* Bottom keeps dot */
		cur_dot = scr[t-1]->sl_boff;	/* but top needs new one. */
	  }
	f_othwind();			/* switch to other window */
	redp(RD_WINDS);			/* Update all windows */
}


/* EFUN: "One Window" */
/*	Revert to using only one window; use the current buffer (unlike
 *	EMACS which always selects the top window's buffer)
 *	Ensures that current window's vars are correctly set for
 *	new dimensions (w_pos, w_ht, plus w_topldot to minimize redisplay),
 *	then kills unneeded windows.
 */
f_1wind()
{	register struct window *w;

	if (oth_win == 0)
	  {
#if (!IMAGEN)
		ding("Only 1 window");
#endif /*-IMAGEN*/
		return;
	  }
	w = cur_win;
	if(w->w_pos)		/* If not top window */
	  {	d_fixcur();		/* Ensure screen-line data correct */
		e_go(w->w_topldot);	/* Beginning from top of window, */
		d_fgoloff(-w->w_pos);	/* Move back enough lines */
		w->w_topldot = e_dot();	/* To set new start of window */
		e_gocur();		/* Then move back to orig place */
		w->w_pos = 0;
	  }
	w->w_ht += oth_win -> w_ht + 1;
	kill_win (oth_win);
	kill_win (sep_win);
	oth_win = sep_win = 0;
#if FX_2MODEWINDS
	chk2modws();	/* Update notion of whether have 2 mode winds */
#endif
	redp(RD_FIXWIN|RD_WINDS|RD_MODE); /* New topldot for this window,
					 * and check all remaining windows */
}

/* EFUN: "Other Window" */
/*	Move to the "other" user window.
 */
f_othwind ()
{	if (oth_win == 0)
	  {
#if !(IMAGEN)
		ding("Only 1 window");
#endif /*-IMAGEN*/
		return;
	  }
	chg_win(oth_win);
	oth_win = user_win;
	user_win = cur_win;
	redp(RD_MODE);
}

/* EFUN: "Grow Window" */
/*	Grow the current window - while in two window mode,
 *	increase the size of the current window by the arg
 *	and decrease the other accordingly
 */
f_growind()
{	register struct window *cw, *ow;
	register int e;

	if ((ow = oth_win) == 0)
	  {
#if !(IMAGEN)
		ding("Only 1 window");
#endif /*-IMAGEN*/
		return;
	  }
	e = exp;
	if((cw = cur_win)->w_pos != 0)	/* If current window is on bottom */
	  {	cw = ow;		/* Then fake code to think it's top */
		ow = cur_win;
		e = -e;
	  }
	if(  cw->w_ht + e < 1
	  || ow->w_ht + e < 1)
	  {	ding("Too much");
		return;
	  }
	cw -> w_ht += e;
	ow -> w_pos += e;
	ow -> w_ht -= e;
	sep_win -> w_pos += e;
	redp(RD_WINDS | RD_MODE);		/* Update all windows */
}

#if FX_SHRINKWIND
/* EFUN: "Shrink Window" (not EMACS) - from IMAGEN config */
f_shrinkwind()
{
	if (! oth_win)
		return;
	f_othwind();
	f_growind();
	f_othwind();
}
#endif /*FX_SHRINKWIND*/

#if FX_DELWIND
/* EFUN: "Delete Window" (not EMACS) - from IMAGEN config */
f_delwind()
{
	if(!oth_win)
		return;
	f_othwind();
	f_1wind();
}
#endif /*FX_DELWIND*/

#if FX_SOWIND
/* EFUN: "Standout Window" (not EMACS) */
/*	Toggles the display standout mode for the current window.
**	With argument of 4, toggles the standout mode for the non-buffer
**	parts of the screen, such as the ELLE mode line.
** (This corresponds to FS INVMOD$ in EMACS)
**	With argument of 0, turns standout mode off for all windows.
*/
/* It suffices to set the window flag bit and force a RD_WINRES for that
 * window; the redisplay code will do the rest.
*/
static void tgso_wind();

f_sowind()
{
	register struct window *w;
	switch(exp)
	  {	default:		/* Toggle current window */
			tgso_wind(cur_win);
			break;
		case 4:			/* Toggle mode & separator windows */
			tgso_wind(mode_win);
			tgso_wind(sep_win);	/* This may not exist */
			break;
		case 0:			/* Turn off standout for all winds */
			for(w = win_head; w; w = w->w_next)
				if(w->w_flags&W_STANDOUT)
					tgso_wind(w);
	  }
#if FX_2MODEWINDS
	chk2modws();	/* Update notion of whether have 2 mode winds */
#endif
}

static void
tgso_wind(w)		/* Toggle standout mode for given window */
register struct window *w;
{
	if (w == 0) return;		/* For case of no sep_win */
	if (w->w_flags & W_STANDOUT)
		w->w_flags &= ~W_STANDOUT;
	else w->w_flags |= W_STANDOUT;
	w->w_redp |= RD_WINRES;		/* Re-do this particular window */
	redp(RD_CHKALL);		/* Check all windows for changes */
}
#endif /*FX_SOWIND*/


#if FX_2MODEWINDS
/* EFUN: "Two Mode Windows" (not EMACS) */
/*	With arg, sets ev_2modws to that value (0, 1, or 2).
**	No arg, toggles current setting between 0 and 2.
*/

f_2modewinds()
{
	ev_2modws = exp_p ? exp : (ev_2modws ? 0 : 2);
	chk2modws();
}

/* CHK2MODWS - Called after anything changes which might affect
**	whether 2 mode windows are in effect or not.  Fixes up
**	sep_win to either be or not be a mode window.
*/
chk2modws()
{	register struct window *w;
	static struct buffer *sep_buf = 0;

	if(!(w = sep_win))
	  {	sepmode_p = 0;		/* Don't have 2 windows at all */
		return;
	  }
	sepmode_p = (ev_2modws == 1)
			? (mode_win->w_flags&W_STANDOUT)
			: ev_2modws;

	if(sepmode_p)		/* Turn 2-mode-winds on? */
	  {
		if(!sep_buf)
			sep_buf = make_buf(" **SEPMODE**");
		w->w_buf = sep_buf;
		w->w_flags |= W_MODE;
	  }
	else			/* Turn 2-mode-winds off */
	  {	w->w_buf = lines_buf;
		w->w_flags &= ~W_MODE;
		redp(RD_CHKALL);	/* No longer a mode win, so must */
					/* check all to ensure it's updated */
	  }
	w->w_redp |= RD_WINRES;
	redp(RD_MODE);
}
#endif /*FX_2MODEWINDS*/

init_win ()
{
	win_head = 0;
	oth_win = 0;
	user_win = make_win(0, scr_ht - (ECHOLINES+1), cur_buf); /* Main */
	mode_win = make_win(scr_ht - (ECHOLINES+1), 1, make_buf(" **MODE**"));
	ask_win  = make_win(scr_ht - ECHOLINES,     1, make_buf(" **ASK**"));
#if FX_SOWIND
	if(ev_modwso)
		mode_win->w_flags |= W_STANDOUT;
#endif

	cur_win = user_win;
}

chg_win(newwin)		       /* change current window to newwin */
struct window *newwin;
{
	cur_win->w_dot = cur_dot;	/* Save window's current dot */
	cur_win->w_redp |= rd_type&RDS_WINFLGS;	/* and its redisplay flags */
	cur_win = newwin;		/* OK, switch to new current window */
	cur_buf = newwin->w_buf;	/* Set new buffer from win */
	e_gosetcur(newwin->w_dot);	/* Set new cur_dot from win too */
			/* Note done this way to canonicalize the location
			** (may be past new EOB) and ensure SB buffer
			** internals agree with cur_dot.
			*/
	rd_type &= ~RDS_WINFLGS;	/* Remove old per-window flags */
	redp(RD_WINRES|RD_MODE);	/* Maybe caller shd handle? */
			/* Note WINRES must be set in case we are pointing
			 * to a buffer that was modified while we were in
			 * the other window!
			 */
}


struct window *
make_win (pos, ht, buf)
int pos, ht;
struct buffer *buf;
{	register struct window *w;
	register struct buffer *b;

	b = buf;
	w = (struct window *) memalloc(sizeof (struct window));
	w->w_flags = 0;
	w->w_pos = pos;
	w->w_ht = ht;
	w->w_buf = b;
	w->w_dot = b->b_dot;	/* Set dot from buffer value */
	w->w_topldot = 0;	/* Set top of window to beg of buffer */
	w->w_pct = 200;		/* Assume "ALL" */
	w->w_bmod = 0;
	w->w_emod = 0;
	w->w_oldz = 0;
	w->w_redp = RD_WINRES;	/* Window will need complete update */
	w->w_next = win_head;	/* Done, now link it in */
	win_head = w;
	return (w);
}

kill_win (win)
struct window *win;
{	register struct window *w, *w1, *kw;

	kw = win;
	w1 = 0;
	for (w = win_head; w && w != kw; w = w -> w_next)
		w1 = w;
	if (w == 0)
	  {	ring_bell();
		errbarf("No such window");	/* Internal error */
		return;
	  }
	if (w1 == 0)
		win_head = w -> w_next;
	else
		w1 -> w_next = w -> w_next;
	kw->w_buf->b_dot = (kw == cur_win) ? cur_dot : kw->w_dot;
	chkfree (kw);
#if IMAGEN		/* Not needed? */
	redp (RD_WINRES|RD_WINDS|RD_REDO);
#endif /*IMAGEN*/
}

/*
 * "Show-window" routines, used to set up, step through, and close a
 * temporary "show" window.
 * MK_SHOWIN(bufp)
 * UP_SHOWIN()
 * KL_SHOWIN()
 */

/* MK_SHOWIN(bufp) - Temporarily display a buffer
 */
mk_showin(b)
struct buffer *b;
{	register struct window *w;
	register int i;
	int moreflg, intflg;		/* Interrupt flag */
	struct window *savwin;

	/* First must set up special window... */
	savwin = cur_win;
	chg_win(w = make_win(0, scr_ht-(ECHOLINES+3), b));
 redo:
	d_fixcur();		/* Fix up screen image of current window */

	/* Find how many lines actually used, and reduce size to that */
	i = w->w_ht;
	while(--i >= 0)
	  {
		if(scr[i]->sl_boff != w->w_oldz) break;
	  }
	if(++i <= 0)
		goto skipit;	/* Punt the whole thing */
	if(!(moreflg = (i >= w->w_ht)))
		w->w_ht = i;	/* Reduce size of window */

	intflg = upd_wind(w);	/* Update the window! */
	if(!intflg)		/* Unless input waiting, add prompt. */
	  {
		yellat( moreflg ?
	"--MORE-- (type Space for more, or type any command to flush)" :
	"------------------------------------------------ (Hit space to continue)--",
			w->w_ht);
		
	  }
	tbufls();		/* Ensure all output forced out */
	i = cmd_read();		/* then wait for user to input a char */
	if(i == SP)
	  {	if(moreflg)
		  {	yellat("", w->w_ht);
			d_screen(1);
			w->w_redp |= RD_WINRES;
			goto redo;
		  }
	  }
#if !(IMAGEN)		/* IMAGEN - always ignore what was typed */
	else unrchf = i;
#endif /*-IMAGEN*/
skipit:	chg_win(savwin);
	kill_win(w);
	redp(RD_WINDS);		/* Update all remaining windows */
}

/* Mode Line generation */

struct window *
make_mode(bw)
register struct window *bw;	/* Base window we are reporting status of */
{
	register struct buffer *b;	/* Buffer of this window */
	struct window *mw, *savew;	/* Save current window */
	struct buffer *saveb;	/* and current buffer (in case different) */
	char temp[20];

	saveb = cur_buf;	/* Save values prior to context switch */
	savew = cur_win;
	b = bw->w_buf;		/* Get buffer for that window */

#if FX_2MODEWINDS
	if((mw = sep_win) && (mw->w_flags&W_MODE) &&
	    (bw->w_pos == 0))		/* Base window is top window? */
	  {				/* Use sep_win as mode wind */
	  }
	else
#endif
		mw = mode_win;		/* Default is normal mode window */
	chg_win(mw);			/* Go to mode line window */
	e_gobob();			/* go to beginning */
	e_reset();			/* Flush buffer */
#if IMAGEN
	e_sputz(" ");
	e_sputz(b->b_name);
	if (b -> b_flags & B_MODIFIED)
		e_sputz("*");
	e_sputz(" (");
	if (b->b_flags & B_QUERYREP)
		e_sputz("[Query Replace] ");
	if (b->b_flags & B_CMODE)
		e_sputz("C");
	else if (b->b_flags & B_TEXTMODE)
		e_sputz("Text");
	else
		e_sputz("Fundamental");
	e_sputz(")  ");
	if (b->b_fn)
		e_sputz(b->b_fn);
	e_sputz("      ");
#else
	e_sputz(ev_verstr);		/* Editor name/version */
	e_sputz(" (");
	e_sputz(cur_mode->mjm_name);	/* insert major mode name */
#if FX_FILLMODE
	if(fill_mode) e_sputz(" Fill");
#endif /*FX_FILLMODE*/
#if FX_SKMAC
	if(kdef_mode) e_sputz(" MacroDef");
#endif /*FX_SKMAC*/
	e_sputz(") ");
	e_sputz(b->b_name);		/* buffer name */
	e_sputz(": ");
	if (b->b_fn)
		e_sputz(b->b_fn);       /* file name */
	if (b->b_flags & B_MODIFIED)
		e_sputz(" *");
	else	e_sputz("  ");
#endif /*-IMAGEN*/
	if(bw->w_pct < 200)		/* Not ALL? */
	  {	e_sputz(" --");
		switch(bw->w_pct)
		  {	case -1:
				e_sputz("TOP");
				break;
			case 150:
				e_sputz("BOT");
				break;
			default:
				dottoa(&temp[0],(chroff)bw->w_pct);
				e_sputz(&temp[0]);
				e_putc('%');
		  }
		e_sputz("--");
	  }
#if FX_SOWIND
	if(mw->w_flags&W_STANDOUT)
		e_insn(SP, (int)(scr_wd0 - e_blen()));	/* Stuff out with spaces */
#endif

	redp(RD_WINRES);
	chg_win(savew);		/* Restore context */
	chg_buf(saveb);
	return(mw);		/* Return mode window */
}


buf_mod()
{	register struct buffer *b;

	b = cur_buf;
	if((b->b_flags & B_MODIFIED) == 0)
	  {	b->b_flags |= B_MODIFIED;
		redp(RD_MODE);
	  }
}

/* BUF_TMOD - called when text modified in buffer, to set all
 *	the appropriate indicators so that redisplay works right.
 *	Changed text is everything from CUR_DOT to the given offset
 *	from same.  If stuff was deleted, offset should be 0.
 * BUF_TMAT - similar but argument is location of other end of range,
 *	when caller knows that and wants life easy.
 */

buf_tmat(dot)
chroff dot;
{	buf_tmod(dot - cur_dot);	/* Convert to offset */
}
buf_tmod(offset)
chroff offset;
{	register struct window *w;
	chroff a, b, tmp;

	w = cur_win;
	a = cur_dot;
	b = a + offset;
	if(a > b)	/* Get into right order */
	  {	tmp = a;
		a = b;
		b = tmp;
	  }
	b = e_blen() - b;	/* Make upper bound relative to EOB */
	if(w->w_bmod < 0)	/* Have range vars been set yet? */
	  {	w->w_bmod = a;	/* Nope, so can just set 'em now. */
		w->w_emod = b;
	  }
	else
	  {	if(a < w->w_bmod)
			w->w_bmod = a;
		if(b < w->w_emod)
			w->w_emod = b;
	  }
	buf_mod();		/* Maybe later just insert here? */
	redp(RD_TMOD);
}