// move in the optimal way from (OldCol,OldRow) to (c,r)
static void TI_CURSOR_MOVE( int c, int r )
{
unsigned newLen;
int i;
struct {
int r,c;
} len = { 0, 0 };
struct {
enum {
none,
absolute,
rel_parm_plus,
relative_plus,
rel_parm_minus,
relative_minus
} r,c;
} method = { none, none };
// Just use cursor_address if we're not supposed to optimize
if( !OptimizeTerminfo ) {
putp( tparm( cursor_address, r, c ) );
OldRow = r;
OldCol = c;
return;
}
// return if we're in the right place
if( OldCol == c && OldRow == r )
return;
// if OldRow or OldCol <0 then the old position is invalid
if( OldCol >= 0 && OldRow >= 0 ) {
if( OldRow != r ) {
method.r = absolute;
len.r = strlen( tparm( row_address, r ) );
if( OldRow < r ) {
newLen = strlen( tparm( parm_down_cursor, r - OldRow ) );
pickMethod( r, rel_parm_plus );
newLen = ( r - OldRow ) * strlen( cursor_down );
pickMethod( r, relative_plus );
} else {
newLen = strlen( tparm( parm_up_cursor, OldRow - r ) );
pickMethod( r, rel_parm_minus );
newLen = ( OldRow - r ) * strlen( cursor_up );
pickMethod( r, relative_minus );
}
}
if( OldCol != c ) {
method.c = absolute;
len.c = strlen( tparm( column_address, c ) );
if( OldCol < c ) {
newLen = strlen( tparm( parm_right_cursor, c - OldCol ) );
pickMethod( c, rel_parm_plus );
newLen = ( c - OldCol ) * strlen( cursor_right );
pickMethod( c, relative_plus );
} else {
newLen = strlen( tparm( parm_left_cursor, OldCol - c ) );
pickMethod( c, rel_parm_minus );
newLen = ( OldCol - c ) * strlen( cursor_left );
pickMethod( c, relative_minus );
}
}
}
// check to make sure the method we have so far is valid
if( ( OldRow >= 0 && OldCol >= 0 )
&& ( len.r != 0 || method.r == none )
&& ( len.c != 0 || method.c == none )
&& ( ( len.r + len.c ) < strlen( tparm( cursor_address, r, c ) ) )
&& ( ( len.r + len.c ) < strlen( cursor_home ) || cursor_home[0] == '\0' ) ) {
switch( method.c ) {
case none:
break;
case absolute:
putp( tparm( column_address, c ) );
break;
case rel_parm_plus:
putp( tparm( parm_right_cursor, c - OldCol ) );
break;
case relative_plus:
for( i = 0; i < c - OldCol; i++ ) {
putp( cursor_right );
}
break;
case rel_parm_minus:
putp( tparm( parm_left_cursor, OldCol - c ));
break;
case relative_minus:
for( i = 0; i < OldCol - c; i++ ) {
putp( cursor_left );
}
break;
}
switch( method.r ) {
case none:
break;
case absolute:
putp( tparm( row_address, r ) );
break;
case rel_parm_plus:
putp( tparm( parm_down_cursor, r - OldRow ) );
break;
case relative_plus:
for( i = 0; i < r - OldRow; i++ ) {
putp( cursor_down );
}
break;
case rel_parm_minus:
putp( tparm( parm_up_cursor, OldRow - r ) );
break;
case relative_minus:
for( i = 0; i < OldRow - r; i++ ) {
putp( cursor_up );
}
break;
}
} else if( r == 0 && c == 0
&& cursor_home[0] != '\0'
&& strlen( cursor_home ) <= strlen( tparm( cursor_address, r, c ) ) ) {
putp( cursor_home );
} else {
putp( tparm( cursor_address, r, c ) );
}
OldCol = c;
OldRow = r;
}
// move in the optimal way from (OldCol,OldRow) to (c,r)
void TI_CURSOR_MOVE( register int c, register int r )
/**********************************************************/
{
unsigned newLen;
int i;
unsigned len_cursor_address;
unsigned len_cursor_home;
int row;
int col;
struct {
int r,c;
} len= { 0, 0 };
struct {
enum {
none,
absolute,
rel_parm_plus,
relative_plus,
rel_parm_minus,
relative_minus
} r,c;
} method= { none, none };
// Return if we're in the right place
if( OldCol == c && OldRow == r ) {
return;
}
// Just use cursor_address if we're not supposed to optimize.
// If cursor_address isn't supported then use cursor_home,
// cursor_down and cursor_left.
if( !OptimizeTerminfo ) {
if( _capable_of( cursor_address ) ) {
__putp( UNIX_TPARM3( cursor_address, r, c ) );
} else if( _capable_of( cursor_home )
&& _capable_of( cursor_down )
&& _capable_of( cursor_right )
) {
__putp( cursor_home );
for( row = 0; row < r; row++ ) {
__putp( cursor_down );
}
for( col = 0; col < c; col++ ) {
__putp( cursor_right );
}
}
OldRow= r;
OldCol= c;
return;
}
// If we're not supposed to optimize or if the term is
// not capable of cursor_address:
// if OldRow or OldCol <0 then the old position is invalid
if( OldCol>=0 && OldRow>=0 ){
if( OldRow!=r ){
method.r= absolute;
setLenParm( len.r, row_address, r )
if( OldRow<r ) {
setLenParm( newLen, parm_down_cursor, r-OldRow )
pickMethod( r, rel_parm_plus );
if( _capable_of( cursor_down ) ) {
newLen= (r-OldRow)*strlen( cursor_down );
} else {
newLen= 0;
}
pickMethod( r, relative_plus );
} else {
setLenParm( newLen, parm_up_cursor, OldRow-r )
pickMethod( r, rel_parm_minus );
if( _capable_of( cursor_up ) ) {
newLen= (OldRow-r)*strlen( cursor_up );
} else {
newLen= 0;
}
pickMethod( r, relative_minus );
}
}
if( OldCol!=c ){
method.c= absolute;
setLenParm( len.c, column_address, c )
if( OldCol<c ) {
setLenParm( newLen, parm_right_cursor, c-OldCol )
pickMethod( c, rel_parm_plus );
if( _capable_of( cursor_right ) ) {
newLen= (c-OldCol)*strlen( cursor_right );
} else {
newLen= 0;
}
pickMethod( c, relative_plus );
} else {
setLenParm( newLen, parm_left_cursor, OldCol-c )
pickMethod( c, rel_parm_minus );
if( _capable_of( cursor_left ) ) {
newLen= (OldCol-c)*strlen( cursor_left );
} else {
newLen= 0;
}
pickMethod( c, relative_minus );
}
}
