minix/commands/elle/eefd.c
2009-11-09 10:26:00 +00:00

434 lines
11 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* ELLE - Copyright 1982, 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.
*/
/* EEFD Display control functions
*/
#include "elle.h"
#if FX_NEWWIN
/* EFUN: "New Window" */
/* Clear current window and set as requested.
* ^L - clear current window and redisplay it (default top)
* <arg>^L - select new window so that current line is
* the <arg>'th from top of window (0 = top line)
* ^U^L - clear current line and redisplay.
*/
f_newwin()
{ register int i, n;
register struct window *w;
d_fixcur(); /* Ensure screen vars correct */
w = cur_win;
if (exp_p)
{ if((n = exp) == 4 && exp_p == 4 /* CTRL-U? */
&& (i = d_line(cur_dot)) >= 0) /* On valid line? */
{ d_lupd(w, i); /* Update it */
return;
}
}
else /* No argument given */
{ redp(RD_SCREEN); /* Clear whole screen (later just window? */
#if IMAGEN
return;
#else
n = (ev_nwpct*w->w_ht)/100; /* Set new window using % */
#endif /*-IMAGEN*/
}
if (n < 0) n = 0; /* Ensure # is reasonable */
else if (n >= w->w_ht)
n = w->w_ht - 1;
d_fgoloff(-n); /* Go up given # of lines */
w->w_topldot = e_dot(); /* Set new top-line dot */
e_gocur(); /* Move back to cur_dot */
redp(RD_FIXWIN); /* Say to re-hack window */
}
#endif /*FX_NEWWIN*/
#if FX_NSCREEN
/* EFUN: "Next Screen" */
f_nscreen()
{ d_screen( exp);
}
#endif /*FX_NSCREEN*/
#if FX_PSCREEN
/* EFUN: "Previous Screen" */
f_pscreen()
{ d_screen(-exp);
}
#endif /*FX_PSCREEN*/
#if FX_OTHNSCREEN
/* EFUN: "Other New Screen" (not EMACS) - from IMAGEN config */
f_othnscreen()
{
if (! oth_win)
return;
f_othwind();
if (exp_p) /* With arg, back up */
d_screen(-1);
else
d_screen(1);
f_othwind();
redp(RD_WINDS); /* Look at all windows */
}
#endif /*FX_OTHNSCREEN*/
#if FX_LWINDBORD
/* EFUN: "Line to Window Border" (not EMACS) - from IMAGEN config */
f_lwindbord()
{
if (exp_p)
/* With arg, means "to bottom" */
exp = cur_win->w_ht - 1;
else
/* Else, to top */
exp = 0;
/* Just a "front end" for ^L */
exp_p = 1;
f_newwin();
}
#endif /*FX_LWINDBORD*/
#if FX_SCUPWIND
/* EFUN: "Scroll Window Up" (not EMACS) - from IMAGEN config */
f_scupwind()
{
scroll_win(exp);
}
#endif /*FX_SCUPWIND*/
#if FX_SCDNWIND
/* EFUN: "Scroll Window Down" (not EMACS) - from IMAGEN config */
f_scdnwind()
{
scroll_win(-exp);
}
#endif /*FX_SCDNWIND*/
#if FX_MVWTOP
/* EFUN: "Move to Window Top" (not EMACS) - from IMAGEN config */
f_mvwtop()
{
extern moveborder();
moveborder(1);
}
#endif /*FX_MVWTOP*/
#if FX_MVWBOT
/* EFUN: "Move to Window Bottom" (not EMACS) - from IMAGEN config */
f_mvwbot()
{
extern moveborder();
moveborder(0);
}
#endif /*FX_MVWBOT*/
#if FX_NSCREEN || FX_PSCREEN || FX_OTHNSCREEN
/* Move to new loc by N screenfuls.
* If moving downward, keep bottom 2 lines of current screen on top of next.
* If moving up, keep top 2 lines of current screen on bottom of next.
*/
d_screen(rep)
int rep;
{
register int i;
register struct window *w;
chroff newdot;
w = cur_win;
if((i = w->w_ht - 2) <= 0) /* Just-in-case check */
i = 1;
if((i *= rep) == 0)
return;
d_fixcur(); /* Ensure window fixed up */
e_go(w->w_topldot); /* Start at top of screen */
d_fgoloff(i);
/* Find where we are now, and make that the new top of window. */
if((newdot = e_dot()) != e_blen()) /* If not at EOF, */
w->w_topldot = newdot; /* set new top of window! */
else w->w_topldot = 0; /* Else let fix_wind select top. */
e_setcur(); /* Ensure cur_dot set to real loc */
#if IMAGEN
redp(RD_WINRES|RD_REDO); /* HINT: just repaint screen */
#else
redp(RD_FIXWIN|RD_MOVE);
#endif /*-IMAGEN*/
}
#endif /*FX_NSCREEN || FX_PSCREEN || FX_OTHNSCREEN*/
#if FX_SCUPWIND || FX_SCDNWIND /* If want scroll-window function */
scroll_win(n)
register int n;
{ register struct window *w = cur_win;
chroff savdot;
if (n == 0) return;
d_fixcur(); /* Ensure screen vars for win all set up */
e_go(w->w_topldot); /* Go to top of current window */
d_fgoloff(n); /* Move given # of display lines */
w->w_topldot = e_dot(); /* Set new top of window */
redp(RD_FIXWIN); /* Say new window needs fixing up */
/* Now adjust position of current dot so it is still within window */
if (n > 0)
{ /* Moving screen text "up" (win down) */
if (cur_dot < w->w_topldot) /* See if scrolled off top */
e_setcur(); /* yes, make dot be win top */
}
else { /* Moving screen text "down" (win up) */
savdot = cur_dot; /* Save since must temporarily */
e_setcur(); /* set current dot within window, */
d_fixcur(); /* so screen can be fixed up. */
if (inwinp(w, savdot)) /* Now see if old dot in new win */
cur_dot = savdot; /* Yes, just restore it! */
else /* No, make it beg of bottom line. */
cur_dot = scr[w->w_pos + w->w_ht - 1]->sl_boff;
}
e_gocur(); /* Make current pos be cur_dot */
}
#endif /* FX_SC%%WIND */
#if FX_MVWTOP || FX_MVWBOT /* Guts for above two functions */
static
moveborder(top)
int top;
{
d_fixcur(); /* Ensure current win screen image fixed up */
e_gosetcur(top ? cur_win->w_topldot
: scr[cur_win->w_pos + cur_win->w_ht - 1]->sl_boff);
redp(RD_MOVE); /* Should only be cursor adjustment */
}
#endif /*FX_MVW%%%*/
/* Given a line and a position in that line, return the xpos.
* NOTE CAREFULLY that when line extends over several screen lines,
* the value returned is the screen X position even though it
* may be some lines down from the start of the logical line!
* Also note this won't work very well if tabs exist on the extra
* lines. This rtn should not be used for cursor positioning.
* Also note: d_ncols() will never return -1 meaning EOL because the
* setup guarantees there is no EOL within the range checked.
*/
d_curind() /* Find current indentation */
{ indtion(e_dot());
}
indtion(lin)
chroff lin;
{ register int i, col;
chroff savdot;
chroff nchars;
savdot = e_dot(); /* Save current position */
e_go(lin); /* Go to line caller wants */
e_gobol(); /* Go to its beginning */
col = 0; /* Start at left margin */
if((nchars = lin - e_dot()) > 0)
do {
if(nchars < (i = scr_wd0))
i = nchars;
if((col = d_ncols(i, col)) < 0) /* Hit edge of screen? */
col = 0; /* Reset to left margin */
} while((nchars -= i) > 0);
e_go(savdot); /* Restore current position */
return(col);
}
/* ININDEX - How many positions in lin must we go to get to xpos?
* Returns -1 if can't be done. Assumes "lin" is at beginning of a line!
*/
inindex (lin, xpos)
chroff lin;
int xpos;
{ register int col, x;
chroff savdot;
char tmp[MAXLINE+MAXCHAR];
extern int sctreol; /* From EEDISP */
if((x = xpos) <= 0) return(0);
if(x >= MAXLINE) return(-1); /* ?!? */
col = 0;
savdot = e_dot();
e_go(lin); /* Assumes this is start of line */
col = sctrin(tmp, x, 0); /* Translate from sb_getc input */
if((col - x) >= 0) /* Exact count-out or past it? */
{ x = e_dot() - lin; /* Yup, win. */
if (sctreol > 0) /* Did we hit (and include) EOL? */
#if FX_EOLMODE /* If so, back up over the EOL. */
x -= eolcrlf(cur_buf) ? 2 : 1;
#else
--x;
#endif
}
else x = -1; /* Nope, EOL or EOF hit too soon. */
e_go(savdot);
return(x);
}
/*
* D_ ROUTINES - display-relative functions. Similar to E_, but
* a "line" is defined as one line of the screen rather than
* as a logical text line. Also, for efficiency reasons
* arguments are given saying how many lines to hack.
*/
d_gopl() { return(d_goloff(-1)); }
d_gonl() { return(d_goloff( 1)); }
/* D_GOLOFF(i) - Go to beginning of a display line
* D_FGOLOFF(i) - ditto, but assumes screen image of window already fixed up.
* i - # of lines offset. Negative moves up, positive down.
* Zero arg goes to beginning of current display line.
* Side effects: screen image of window is fixed up at
* start of routine, but is NOT updated by the move to new location.
*/
d_goloff(cnt)
int cnt;
{ d_fixcur();
d_fgoloff(cnt); /* Now can invoke fixed-up fast version */
}
d_fgoloff(cnt)
register int cnt;
{ register int y;
struct scr_line l;
char line[MAXLINE+MAXCHAR];
int top, bot;
/* Find current position in window, since can save time
* by using stuff already in fixed-up screen image.
*/
if((y = d_line(e_dot())) < 0) /* Get current Y position */
{
errbarf("Dot out of window");
y = 0;
}
top = cur_win->w_pos; /* 1st line of window */
bot = top + cur_win->w_ht; /* 1st line not in window */
l.sl_boff = scr[y]->sl_boff;
l.sl_nlin = &line[0];
l.sl_cont = 0;
if(cnt > 0) goto down;
/* Go upwards. This is hairy because we want to be clever about
* huge logical lines -- avoid going all the way back to BOL.
*/
if((y+cnt) >= top) /* Fits? */
goto onscr; /* Hurray, hack it! */
cnt += y - top; /* Sigh, find # lines to skip */
y = top;
l.sl_boff = scr[y]->sl_boff;
e_go(l.sl_boff);
/* Okay, here's the hairy part. Must go backwards from top
* line; if no EOL within scr_wid*cnt chars, then simply assume one is
* seen.
*/
cnt = -cnt;
d_backup(cnt);
return; /* Really should re-adjust stuff, but... */
/* Go downwards. Not too bad... */
down:
if((y+cnt) <= bot) /* Fits? */
goto onscr; /* Hurray, hack it! */
cnt -= bot - y; /* Sigh, find # lines can skip */
y = bot - 1;
l.sl_boff = scr[y]->sl_boff + scr[y]->sl_len;
if(y > top
&& (l.sl_cont = scr[y-1]->sl_cont))
l.sl_line = scr[y-1]->sl_line;
e_go(l.sl_boff);
do {
fix_line(&l,&l);
} while(--cnt > 0 && l.sl_len);
return;
onscr: if((y += cnt) >= bot)
{ --y;
e_go(scr[y]->sl_boff + scr[y]->sl_len);
}
else e_go(scr[y]->sl_boff);
}
/* D_FIXCUR() - Ensure current window is fixed up, with
* current location (not necessarily cur_dot)!
* Ensure cur_dot reflects real loc so that fix_wind will work,
* and always call fix_wind to ensure that screen image vars
* are set properly. Note any active redisplay flags must be carried
* on into window redisplay flags, so fix_wind will notice them.
*/
d_fixcur()
{ register struct window *w;
chroff savedot;
w = cur_win;
savedot = cur_dot;
e_setcur();
w->w_redp |= rd_type&RDS_WINFLGS;
fix_wind(w); /* Always ensure window is set up! */
redp(w->w_redp); /* Add back new flags */
rd_type &= ~RDS_DOFIX; /* and flush fix-invoking ones */
cur_dot = savedot; /* Restore cur_dot, no longer hacked. */
}
d_backup(nlin) /* Try to back up by nlin screen lines */
int nlin;
{ register int cnt, n, c;
int eolstop;
if((cnt = nlin+1) <= 0) return;
c = 0;
do
{ n = scr_wid;
eolstop = 0; /* Not yet stopped at EOL */
do { if((c = e_rgetc()) == EOF)
return;
if(c == LF)
{
#if FX_EOLMODE
if(eolcrlf(cur_buf))
{ if((c = e_rgetc()) == CR)
{ eolstop++;
break;
}
if(c != EOF)
e_getc();
}
else
#endif
{ eolstop++;
break;
}
}
} while(--n);
} while(--cnt);
if(eolstop)
{
#if FX_EOLMODE
if(eolcrlf(cur_buf)) e_getc(); /* Skip back over CR */
#endif
e_getc(); /* Skip back over LF */
}
/* At this point, dot is guaranteed to be less than goal,
* which is the important thing for fix_wind, which can handle
* things okay if dot is off bottom of window.
*/
return(1); /* Say always test result */
}