/*
- * Copyright (c) 1981 Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1981, 1993
+ * The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
*/
#ifndef lint
-static char sccsid[] = "@(#)cr_put.c 5.5 (Berkeley) 6/1/90";
-#endif /* not lint */
+static char sccsid[] = "@(#)cr_put.c 8.2 (Berkeley) 1/9/94";
+#endif /* not lint */
-# include "curses.ext"
+#include <curses.h>
+#include <string.h>
-# define HARDTABS 8
-
-extern char *tgoto();
-int plodput();
+#define HARDTABS 8
/*
- * Terminal driving and line formatting routines.
- * Basic motion optimizations are done here as well
- * as formatting of lines (printing of control characters,
+ * Terminal driving and line formatting routines. Basic motion optimizations
+ * are done here as well as formatting lines (printing of control characters,
* line numbering and the like).
*/
-/*
- * Sync the position of the output cursor.
- * Most work here is rounding for terminal boundaries getting the
- * column position implied by wraparound or the lack thereof and
- * rolling up the screen to get destline on the screen.
- */
-
-static int outcol, outline, destcol, destline;
+/* Stub function for the users. */
+int
+mvcur(ly, lx, y, x)
+ int ly, lx, y, x;
+{
+ return (__mvcur(ly, lx, y, x, 0));
+}
-WINDOW *_win;
+static void fgoto __P((int));
+static int plod __P((int, int));
+static void plodput __P((int));
+static int tabcol __P((int, int));
-mvcur(ly, lx, y, x)
-int ly, lx, y, x; {
+static int outcol, outline, destcol, destline;
+/*
+ * Sync the position of the output cursor. Most work here is rounding for
+ * terminal boundaries getting the column position implied by wraparound or
+ * the lack thereof and rolling up the screen to get destline on the screen.
+ */
+int
+__mvcur(ly, lx, y, x, in_refresh)
+ int ly, lx, y, x, in_refresh;
+{
#ifdef DEBUG
- fprintf(outf, "MVCUR: moving cursor from (%d,%d) to (%d,%d)\n", ly, lx, y, x);
+ __CTRACE("mvcur: moving cursor from (%d, %d) to (%d, %d)\n",
+ ly, lx, y, x);
#endif
destcol = x;
destline = y;
outcol = lx;
outline = ly;
- fgoto();
-}
-
-fgoto()
+ fgoto(in_refresh);
+ return (OK);
+}
+
+static void
+fgoto(in_refresh)
+ int in_refresh;
{
- reg char *cgp;
- reg int l, c;
+ register int c, l;
+ register char *cgp;
if (destcol >= COLS) {
destline += destcol / COLS;
outcol %= COLS;
if (AM == 0) {
while (l > 0) {
- if (_pfast)
+ if (__pfast)
if (CR)
- _puts(CR);
+ tputs(CR, 0, __cputchar);
else
- _putchar('\r');
+ putchar('\r');
if (NL)
- _puts(NL);
+ tputs(NL, 0, __cputchar);
else
- _putchar('\n');
+ putchar('\n');
l--;
}
outcol = 0;
destline = LINES - 1;
if (outline < LINES - 1) {
c = destcol;
- if (_pfast == 0 && !CA)
+ if (__pfast == 0 && !CA)
destcol = 0;
- fgoto();
+ fgoto(in_refresh);
destcol = c;
}
while (l >= LINES) {
- /*
- * The following linefeed (or simulation thereof)
- * is supposed to scroll up the screen, since we
- * are on the bottom line. We make the assumption
- * that linefeed will scroll. If ns is in the
- * capability list this won't work. We should
- * probably have an sc capability but sf will
- * generally take the place if it works.
- *
- * Superbee glitch: in the middle of the screen we
- * have to use esc B (down) because linefeed screws up
- * in "Efficient Paging" (what a joke) mode (which is
- * essential in some SB's because CRLF mode puts garbage
- * in at end of memory), but you must use linefeed to
- * scroll since down arrow won't go past memory end.
- * I turned this off after recieving Paul Eggert's
- * Superbee description which wins better.
+ /* The following linefeed (or simulation thereof) is
+ * supposed to scroll up the screen, since we are on
+ * the bottom line. We make the assumption that
+ * linefeed will scroll. If ns is in the capability
+ * list this won't work. We should probably have an
+ * sc capability but sf will generally take the place
+ * if it works.
+ *
+ * Superbee glitch: in the middle of the screen have
+ * to use esc B (down) because linefeed screws up in
+ * "Efficient Paging" (what a joke) mode (which is
+ * essential in some SB's because CRLF mode puts
+ * garbage in at end of memory), but you must use
+ * linefeed to scroll since down arrow won't go past
+ * memory end. I turned this off after recieving Paul
+ * Eggert's Superbee description which wins better.
*/
- if (NL /* && !XB */ && _pfast)
- _puts(NL);
+ if (NL /* && !XB */ && __pfast)
+ tputs(NL, 0, __cputchar);
else
- _putchar('\n');
+ putchar('\n');
l--;
- if (_pfast == 0)
+ if (__pfast == 0)
outcol = 0;
}
}
destline = outline;
if (CA) {
cgp = tgoto(CM, destcol, destline);
- if (plod(strlen(cgp)) > 0)
- plod(0);
- else
- tputs(cgp, 0, _putchar);
- }
- else
- plod(0);
+
+ /*
+ * Need this condition due to inconsistent behavior
+ * of backspace on the last column.
+ */
+ if (outcol != COLS - 1 && plod(strlen(cgp), in_refresh) > 0)
+ plod(0, in_refresh);
+ else
+ tputs(cgp, 0, __cputchar);
+ } else
+ plod(0, in_refresh);
outline = destline;
outcol = destcol;
}
-
/*
* Move (slowly) to destination.
* Hard thing here is using home cursor on really deficient terminals.
static int plodcnt, plodflg;
+static void
plodput(c)
+ int c;
{
if (plodflg)
- plodcnt--;
+ --plodcnt;
else
- _putchar(c);
+ putchar(c);
}
-plod(cnt)
+static int
+plod(cnt, in_refresh)
+ int cnt, in_refresh;
{
- register int i, j, k;
- register int soutcol, soutline;
- chtype ch;
+ register int i, j, k, soutcol, soutline;
plodcnt = plodflg = cnt;
soutcol = outcol;
soutline = outline;
/*
- * Consider homing and moving down/right from there, vs moving
+ * Consider homing and moving down/right from there, vs. moving
* directly with local motions to the right spot.
*/
if (HO) {
/*
- * i is the cost to home and tab/space to the right to
- * get to the proper column. This assumes ND space costs
- * 1 char. So i+destcol is cost of motion with home.
+ * i is the cost to home and tab/space to the right to get to
+ * the proper column. This assumes ND space costs 1 char. So
+ * i + destcol is cost of motion with home.
*/
if (GT)
i = (destcol / HARDTABS) + (destcol % HARDTABS);
else
i = destcol;
- /*
- * j is cost to move locally without homing
- */
+
+ /* j is cost to move locally without homing. */
if (destcol >= outcol) { /* if motion is to the right */
j = destcol / HARDTABS - outcol / HARDTABS;
if (GT && j)
j += destcol % HARDTABS;
else
j = destcol - outcol;
- }
- else
+ } else
/* leftward motion only works if we can backspace. */
if (outcol - destcol <= i && (BS || BC))
- i = j = outcol - destcol; /* cheaper to backspace */
+ /* Cheaper to backspace. */
+ i = j = outcol - destcol;
else
- j = i + 1; /* impossibly expensive */
+ /* Impossibly expensive. */
+ j = i + 1;
- /* k is the absolute value of vertical distance */
+ /* k is the absolute value of vertical distance. */
k = outline - destline;
if (k < 0)
k = -k;
j += k;
- /*
- * Decision. We may not have a choice if no UP.
- */
+ /* Decision. We may not have a choice if no UP. */
if (i + destline < j || (!UP && destline < outline)) {
/*
* Cheaper to home. Do it now and pretend it's a
*/
tputs(HO, 0, plodput);
outcol = outline = 0;
- }
- else if (LL) {
+ } else if (LL) {
/*
* Quickly consider homing down and moving from there.
* Assume cost of LL is 2.
*/
k = (LINES - 1) - destline;
- if (i + k + 2 < j && (k<=0 || UP)) {
+ if (i + k + 2 < j && (k <= 0 || UP)) {
tputs(LL, 0, plodput);
outcol = 0;
outline = LINES - 1;
}
}
- }
- else
- /*
- * No home and no up means it's impossible.
- */
+ } else
+ /* No home and no up means it's impossible. */
if (!UP && destline < outline)
- return -1;
+ return (-1);
if (GT)
i = destcol % HARDTABS + destcol / HARDTABS;
else
i = destcol;
-/*
- if (BT && outcol > destcol && (j = (((outcol+7) & ~7) - destcol - 1) >> 3)) {
+#ifdef notdef
+ if (BT && outcol > destcol &&
+ (j = (((outcol+7) & ~7) - destcol - 1) >> 3)) {
j *= (k = strlen(BT));
if ((k += (destcol&7)) > 4)
j += 8 - (destcol&7);
j += k;
}
else
-*/
+#endif
j = outcol - destcol;
+
/*
- * If we will later need a \n which will turn into a \r\n by
- * the system or the terminal, then don't bother to try to \r.
+ * If we will later need a \n which will turn into a \r\n by the
+ * system or the terminal, then don't bother to try to \r.
*/
- if ((NONL || !_pfast) && outline < destline)
+ if ((NONL || !__pfast) && outline < destline)
goto dontcr;
+
/*
- * If the terminal will do a \r\n and there isn't room for it,
- * then we can't afford a \r.
+ * If the terminal will do a \r\n and there isn't room for it, then
+ * we can't afford a \r.
*/
if (NC && outline >= destline)
goto dontcr;
+
/*
- * If it will be cheaper, or if we can't back up, then send
- * a return preliminarily.
+ * If it will be cheaper, or if we can't back up, then send a return
+ * preliminarily.
*/
if (j > i + 1 || outcol > destcol && !BS && !BC) {
/*
- * BUG: this doesn't take the (possibly long) length
- * of CR into account.
+ * BUG: this doesn't take the (possibly long) length of CR
+ * into account.
*/
if (CR)
tputs(CR, 0, plodput);
}
outcol = 0;
}
-dontcr:
- while (outline < destline) {
+
+dontcr: while (outline < destline) {
outline++;
if (NL)
tputs(NL, 0, plodput);
plodput('\n');
if (plodcnt < 0)
goto out;
- if (NONL || _pfast == 0)
+ if (NONL || __pfast == 0)
outcol = 0;
}
if (BT)
while (outcol > destcol) {
if (plodcnt < 0)
goto out;
-/*
+#ifdef notdef
if (BT && outcol - destcol > k + 4) {
tputs(BT, 0, plodput);
outcol--;
outcol &= ~7;
continue;
}
-*/
+#endif
outcol--;
if (BC)
tputs(BC, 0, plodput);
}
while (outcol < destcol) {
/*
- * move one char to the right. We don't use ND space
- * because it's better to just print the char we are
- * moving over.
+ * Move one char to the right. We don't use ND space because
+ * it's better to just print the char we are moving over.
*/
- if (_win != NULL)
- if (plodflg) /* avoid a complex calculation */
+ if (in_refresh)
+ if (plodflg) /* Avoid a complex calculation. */
plodcnt--;
else {
- ch = curscr->_y[outline][outcol];
- if ((ch&_STANDOUT) == (curscr->_flags&_STANDOUT))
- _putchar(ch);
+ i = curscr->lines[outline]->line[outcol].ch;
+ if ((curscr->lines[outline]->line[outcol].attr
+ & __STANDOUT) ==
+ (curscr->flags & __WSTANDOUT))
+ putchar(i);
else
goto nondes;
}
else
-nondes:
- if (ND)
- tputs(ND, 0, plodput);
- else
- plodput(' ');
+nondes: if (ND)
+ tputs(ND, 0, plodput);
+ else
+ plodput(' ');
outcol++;
if (plodcnt < 0)
goto out;
}
-out:
- if (plodflg) {
+
+out: if (plodflg) {
outcol = soutcol;
outline = soutline;
}
- return(plodcnt);
+ return (plodcnt);
}
/*
* hitting a tab, where tabs are set every ts columns. Work right for
* the case where col > COLS, even if ts does not divide COLS.
*/
+static int
tabcol(col, ts)
-int col, ts;
+ int col, ts;
{
- int offset, result;
+ int offset;
if (col >= COLS) {
offset = COLS * (col / COLS);
col -= offset;
- }
- else
+ } else
offset = 0;
- return col + ts - (col % ts) + offset;
+ return (col + ts - (col % ts) + offset);
}