OpenSolaris_b135/lib/libcurses/screen/mvcur.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 1997 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1988 AT&T */
/* All Rights Reserved */
/*
* University Copyright- Copyright (c) 1982, 1986, 1988
* The Regents of the University of California
* All Rights Reserved
*
* University Acknowledgment- Portions of this document are derived from
* software developed by the University of California, Berkeley, and its
* contributors.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*LINTLIBRARY*/
#include <sys/types.h>
#include "curses_inc.h"
/*
* Cursor motion optimization routine. This routine takes as parameters
* the screen positions that the cursor is currently at, and the position
* you want it to be at, and it will move the cursor there very
* efficiently. It isn't really optimal, since several approximations
* are taken in the interests of efficiency and simplicity. The code
* here considers directly addressing the cursor, and also considers
* local motions using left, right, up, down, tabs, backtabs, vertical
* and horizontal addressing, and parameterized motions. It does not
* consider using home down, or taking advantage of automatic margins on
* any of the four directions. (Two of these directions, left and right,
* are well defined by the am and bw capabilities, but up and down are
* not defined, nor are tab or backtab off the ends.)
*
* General strategies considered:
* CA Direct Cursor Addressing
* LM Local Motions from the old position
* HR Home + Local Motions from upper left corner
* HDR Home Down + Local Motions from lower left corner
* CR CR + Local Motions from left margin
*
* Local Motions can include
* Up cuu, cuu1, vpa
* Down cud, cud1, vpa
* Left cul, cul1, hpa, bs, cbt
* Right cuf, cuf1, hpa, tab, char moved over
*/
/* This is called _ISMARK2 so it doesn't conflict with _ISMARK1 in wrefresh.c */
#define _ISMARK2(x) (mks[(x) / BITSPERBYTE] & (1<<((x) % BITSPERBYTE)))
#define H_UP -1
#define H_DO 1
static int Newy;
static int _homefirst(int, int, int, int),
_mvrel(int, int, int, int, int),
_mvvert(int, int, int), _mvhor(int, int, int),
_mvright(int, int, int), _mvleft(int, int, int);
int
mvcur(int cury, int curx, int newy, int newx)
{
int hu, /* cost home + relative */
hd, /* cost home-down + relative */
rl, /* cost relative */
cm; /* cost direct cursor motion */
/* obvious case */
if (cury == newy && curx == newx)
return (OK);
/* not in the right mode for cursor movement */
if (SP->fl_endwin)
return (ERR);
if (!move_standout_mode && curscr->_attrs && !SP->_mks)
_VIDS(A_NORMAL, curscr->_attrs);
if (!move_insert_mode && SP->phys_irm)
_OFFINSERT();
Newy = newy;
/* cost of using cm */
cm = _COST(Cursor_address);
rl = hd = hu = LARGECOST;
/* baudrate optimization */
if (cm < LARGECOST && SP->baud >= 2400 &&
cury >= 0 && cury < curscr->_maxy &&
curx >= 0 && curx < curscr->_maxx) {
if (cursor_down && (newy == (cury + 1)) &&
((newx == curx) || (newx == 0 && carriage_return))) {
if (newx != curx)
_PUTS(carriage_return, 1);
_PUTS(cursor_down, 1);
goto done;
}
/* fast horizontal move */
if (cury == newy && newx < curx - 4 && newx > curx + 4) {
if (newx < curx)
rl = _mvleft(curx, newx, FALSE);
else
rl = _mvright(curx, newx, FALSE);
if (rl < cm) {
if (newx < curx)
rl = _mvleft(curx, newx, TRUE);
else
rl = _mvright(curx, newx, TRUE);
goto done;
}
}
}
/* cost using relative movements */
if (rl >= LARGECOST && cury >= 0 && cury < curscr->_maxy &&
curx >= 0 && curx < curscr->_maxx)
rl = _mvrel(cury, curx, newy, newx, FALSE);
/* cost of homing to upper-left corner first */
if (cursor_home)
hu = _homefirst(newy, newx, H_UP, FALSE);
/* cost of homing to lower-left corner first */
if (cursor_to_ll)
hd = _homefirst(newy, newx, H_DO, FALSE);
/* can't do any one of them */
if (cm >= LARGECOST && rl >= LARGECOST && hu >= LARGECOST &&
hd >= LARGECOST)
return (ERR);
/* do the best one */
if (cm <= rl && cm <= hu && cm <= hd)
_PUTS(tparm_p2(cursor_address, newy, newx), 1);
else
if (rl <= hu && rl <= hd)
(void) _mvrel(cury, curx, newy, newx, TRUE);
else
(void) _homefirst(newy, newx, hu <= hd ?
H_UP : H_DO, TRUE);
done:
/* update cursor position */
/*LINTED*/
curscr->_curx = (short) newx;
/*LINTED*/
curscr->_cury = (short) newy;
return (OK);
}
/* Move by homing first. */
static int
_homefirst(int ny, int nx, int type, int doit)
{
char *home;
int cy, cost;
if (type == H_UP) {
home = cursor_home;
cost = _COST(Cursor_home);
cy = 0;
} else {
home = cursor_to_ll;
cost = _COST(Cursor_to_ll);
cy = curscr->_maxy - 1;
}
if (!home)
return (LARGECOST);
if (!doit)
return (cost + _mvrel(cy, 0, ny, nx, FALSE));
_PUTS(home, 1);
return (_mvrel(cy, 0, ny, nx, TRUE));
}
/* Move relatively */
static int
_mvrel(int cy, int cx, int ny, int nx, int doit)
{
int cv, ch;
/* do in this order since _mvhor may need the curscr image */
cv = _mvvert(cy, ny, doit);
ch = _mvhor(cx, nx, doit);
return (cv + ch);
}
/* Move vertically */
static int
_mvvert(int cy, int ny, int doit)
{
char *ve;
int dy, st_1, st_n, cv;
if (cy == ny)
goto out;
/* cost of stepwise movement */
if (cy < ny) {
dy = ny-cy;
st_1 = _COST(Cursor_down) * dy;
st_n = _COST(Parm_down_cursor);
} else {
dy = cy-ny;
st_1 = _COST(Cursor_up) * dy;
st_n = _COST(Parm_up_cursor);
}
/* cost of using vertical move */
cv = _COST(Row_address);
/* if calculating cost only */
if (!doit)
return ((cv < st_1 && cv < st_n) ? cv :
(st_n < st_1) ? st_n : st_1);
/* do it */
if (cv < st_1 && cv < st_n)
_PUTS(tparm_p1(row_address, ny), 1);
else
if (st_n < st_1) {
if (cy < ny)
_PUTS(tparm_p1(parm_down_cursor, dy), 1);
else
_PUTS(tparm_p1(parm_up_cursor, dy), 1);
} else {
if (cy < ny)
ve = cursor_down;
else
ve = cursor_up;
for (; dy > 0; --dy)
_PUTS(ve, 1);
}
out:
return (0);
}
/* Move horizontally */
static int
_mvhor(int cx, int nx, int doit)
{
int st, ch, hl;
if (cx == nx)
goto out;
/* cost using horizontal move */
ch = _COST(Row_address);
/* cost doing stepwise */
st = cx < nx ? _mvright(cx, nx, FALSE) : _mvleft(cx, nx, FALSE);
/* cost homeleft first */
hl = (_COST(Carriage_return) < LARGECOST) ?
_COST(Carriage_return) + _mvright(0, nx, FALSE) : LARGECOST;
if (!doit)
return ((ch < st && ch < hl) ? ch : (hl < st ? hl : st));
if (ch < st && ch < hl)
_PUTS(tparm_p1(column_address, nx), 1);
else
if (hl < st) {
_PUTS(carriage_return, 1);
(void) _mvright(0, nx, TRUE);
} else {
if (cx < nx)
(void) _mvright(cx, nx, TRUE);
else
(void) _mvleft(cx, nx, TRUE);
}
out:
return (0);
}
/* Move right. */
static int
_mvright(int cx, int nx, int doit)
{
chtype *scp;
char *mks;
int nt, tx, x, stcost, iscont;
if (!cursor_right && !parm_right_cursor)
return (LARGECOST);
scp = curscr->_y[Newy];
mks = magic_cookie_glitch >= 0 ? SP->_mks[Newy] : NULL;
if (cursor_right) {
/* number of tabs used in stepwise movement */
nt = tab ? (nx / TABSIZE - cx / TABSIZE) : 0;
tx = (nt > 0) ? (cx / TABSIZE + nt) * TABSIZE : cx;
/* calculate stepwise cost */
stcost = nt * _COST(Tab);
iscont = 0;
for (x = tx; x < nx; ++x) {
if (iscont == 0 && !ISCBIT(scp[x]))
iscont = 1;
if ((!ceol_standout_glitch && !mks &&
_ATTR(scp[x]) == curscr->_attrs) ||
ceol_standout_glitch || (mks && !_ISMARK2(x))) {
if (!ISMBIT(scp[x]))
stcost += 1;
else if (iscont && !(nx - x == 1 && nx <
curscr->_maxx && ISCBIT(scp[nx])))
stcost += 1;
else
stcost += _COST(Cursor_right);
} else
stcost += _COST(Cursor_right);
}
} else
stcost = LARGECOST;
if (!doit)
return ((_COST(Parm_right_cursor) < stcost) ?
_COST(Parm_right_cursor) : stcost);
/* actually move */
if (_COST(Parm_right_cursor) < stcost)
_PUTS(tparm_p1(parm_right_cursor, nx-cx), 1);
else {
if (SP->phys_irm)
_OFFINSERT();
for (; nt > 0; --nt)
_PUTS(tab, 1);
iscont = 0;
for (x = tx; x < nx; ++x) {
if (iscont == 0 && !ISCBIT(scp[x]))
iscont = 1;
if ((!ceol_standout_glitch && !mks &&
_ATTR(scp[x]) == curscr->_attrs) ||
ceol_standout_glitch || (mks && !_ISMARK2(x))) {
if (!ISMBIT(scp[x]))
(void) _outwch(_CHAR(scp[x]));
else if (iscont && !(nx - x == 1 &&
nx < curscr->_maxx && ISCBIT(scp[nx])))
(void) _outwch(_CHAR(scp[x]));
else
_PUTS(cursor_right, 1);
} else
_PUTS(cursor_right, 1);
}
}
return (0);
}
/* Move left */
static int
_mvleft(int cx, int nx, int doit)
{
int tx, nt, x, stcost;
if (!cursor_left && !parm_left_cursor)
return (LARGECOST);
if (cursor_left) {
/* stepwise cost */
tx = cx;
nt = 0;
if (back_tab) {
/* the TAB position >= nx */
x = (nx % TABSIZE) ? (nx / TABSIZE + 1) * TABSIZE : nx;
/* # of tabs used and position after using them */
if (x < cx) {
nt = (cx / TABSIZE - x / TABSIZE) +
((cx % TABSIZE) ? 1 : 0);
tx = x;
}
}
stcost = nt * _COST(Back_tab) + (tx-nx) * _COST(Cursor_left);
} else
stcost = LARGECOST;
/* get cost only */
if (!doit)
return ((_COST(Parm_left_cursor) < stcost) ?
_COST(Parm_left_cursor) : stcost);
/* doit */
if (_COST(Parm_left_cursor) < stcost)
_PUTS(tparm_p1(parm_left_cursor, cx - nx), 1);
else {
for (; nt > 0; --nt)
_PUTS(back_tab, 1);
for (; tx > nx; --tx)
_PUTS(cursor_left, 1);
}
return (0);
}