source: trunk/minix/commands/elle/eebuff.c@ 9

/* 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);
}