815 lines
25 KiB
C
815 lines
25 KiB
C
/*
|
|
* Author....: Mike Taylor
|
|
* CIS ID....: ?
|
|
*
|
|
* This is an original work by Mike Taylor and is placed in the
|
|
* public domain.
|
|
*
|
|
* Modification history:
|
|
* ---------------------
|
|
*
|
|
* Rev 1.10 22 Apr 2004 15:32:00 David G. Holm <dholm@jsd-llc.com>
|
|
* Corrected all hb_fsSeek calls to use FS_ defines instead of using
|
|
* redefined SEEK_ ones that conflict with the C-level SEEK_ defines.
|
|
* Rev 1.9 ? ?
|
|
* An unknown number of changes were made between Rev 1.8 and Rev 1.10.
|
|
*
|
|
* Rev 1.8 24 May 2002 19:25:00 David G. Holm <dholm@jsd-llc.com>
|
|
* Fixed some problems that caused C++ compiles to fail.
|
|
*
|
|
* Rev 1.7 29 Mar 2002 17:00:00 Walter Negro <anegro@overnet.com.ar>
|
|
* Ported to Harbour
|
|
*
|
|
* Rev 1.6 01 Jan 1995 03:01:00 TED
|
|
* Changed some prototypes to eliminate compiler warnings.
|
|
*
|
|
* Rev 1.5 14 Feb 1994 16:58:42 GLENN
|
|
* Steve Tyrakowski and Kevin Maher modified to be CPMI-compliant.
|
|
*
|
|
* Rev 1.4 18 Nov 1991 02:20:20 GLENN
|
|
* Mike fixed a bug in _ft_DFInit() related to allocating memory. Some
|
|
* users had been reporting problems, but everyone who tested this patch
|
|
* reported success.
|
|
*
|
|
* Rev 1.3 17 Aug 1991 15:25:46 GLENN
|
|
* Don Caton fixed some spelling errors in the doc
|
|
*
|
|
* Rev 1.2 15 Aug 1991 23:08:14 GLENN
|
|
* Forest Belt proofread/edited/cleaned up doc
|
|
*
|
|
* Rev 1.1 14 Jun 1991 19:53:42 GLENN
|
|
* Minor edit to file header
|
|
*
|
|
* Rev 1.0 01 Apr 1991 01:02:46 GLENN
|
|
* Nanforum Toolkit
|
|
*
|
|
*
|
|
*/
|
|
|
|
/* TOFIX: support for reading files with any encoding
|
|
and translating it to unicode for the GT */
|
|
|
|
#include "hbapi.h"
|
|
#include "hbapifs.h"
|
|
#include "hbapigt.h"
|
|
#include "hbstack.h"
|
|
|
|
#define K_STRING 0
|
|
#define K_LIST ( ! K_STRING )
|
|
|
|
#define CR ( ( char ) 13 )
|
|
#define LF ( ( char ) 10 )
|
|
#define FEOF ( ( char ) 26 )
|
|
|
|
#define BUFFERSIZE 4096 /* maximum size of the file buffer */
|
|
#define MAXLINE 255 /* default maximum size of a line */
|
|
|
|
#define TABSET 8
|
|
|
|
typedef struct
|
|
{
|
|
HB_FOFFSET buffoffset; /* offset into buffer of current line */
|
|
HB_FOFFSET fsize; /* file size in bytes */
|
|
HB_ISIZ bufftop, buffbot; /* first and last character in buffer */
|
|
int wintop, winbot; /* first and last character in window */
|
|
int winrow, wincol; /* row and column of window highlight */
|
|
int sline, eline; /* start and end line of window */
|
|
int scol, ecol; /* start and end col of window */
|
|
int height, width; /* height and width of window */
|
|
HB_FHANDLE infile; /* input file handle */
|
|
int maxlin; /* line size */
|
|
HB_ISIZ buffsize; /* buffer size */
|
|
int hlight; /* highlight attribute */
|
|
int norm; /* normal attribute */
|
|
HB_ISIZ kcount; /* number of keys in terminate key list*/
|
|
int colinc; /* col increment amount */
|
|
HB_BOOL bBrowse; /* browse flag */
|
|
HB_BOOL bRefresh; /* HB_TRUE means refresh screen */
|
|
int keylist[ 24 ]; /* terminate key list */
|
|
int keytype; /* K_STRING or K_LIST */
|
|
|
|
HB_BOOL bIsAllocated; /* if buffers were allocated */
|
|
char * buffer; /* file buffer pointer */
|
|
char * lbuff; /* line buffer pointer */
|
|
HB_UCHAR * vseg; /* video segment variable */
|
|
int iCellSize; /* size of one buffer cell */
|
|
} FT_DISPC, * PFT_DISPC;
|
|
|
|
static HB_TSD_NEW( s_dispc, sizeof( FT_DISPC ), NULL, NULL );
|
|
|
|
/* prototypes */
|
|
|
|
static void chattr( PFT_DISPC dispc, int x, int y, int len, int attr );
|
|
static HB_FOFFSET getblock( PFT_DISPC dispc, HB_FOFFSET offset );
|
|
static void buff_align( PFT_DISPC dispc );
|
|
static void win_align( PFT_DISPC dispc );
|
|
static void disp_update( PFT_DISPC dispc, int offset );
|
|
static void windown( PFT_DISPC dispc );
|
|
static void winup( PFT_DISPC dispc );
|
|
static void linedown( PFT_DISPC dispc );
|
|
static void lineup( PFT_DISPC dispc );
|
|
static void filetop( PFT_DISPC dispc );
|
|
static void filebot( PFT_DISPC dispc );
|
|
|
|
/*
|
|
* chattr() replace the color attribute with a new one starting at
|
|
* location x, y and going for length len.
|
|
*
|
|
*/
|
|
|
|
static void chattr( PFT_DISPC dispc, int x, int y, int len, int attr )
|
|
{
|
|
int i;
|
|
|
|
/* calc the screen memory coord */
|
|
HB_UCHAR * vmem;
|
|
|
|
vmem = dispc->vseg + ( y * ( dispc->width + 1 ) * dispc->iCellSize ) + ( x * dispc->iCellSize ) + 1;
|
|
|
|
if( dispc->iCellSize == 4 )
|
|
vmem++;
|
|
|
|
for( i = 0; i <= len; i++, vmem += dispc->iCellSize ) /* write the new attribute value */
|
|
*vmem = ( char ) attr;
|
|
}
|
|
|
|
/*
|
|
* function getblock() reads the text file and returns the a block.
|
|
* the variables offset and buffsize tell it where to start reading and
|
|
* how many bytes to try to read. if the block read in would not fill
|
|
* the buffer then the offset is adjusted so that the start or end of
|
|
* of the file is positioned at the head or tail of the buffer.
|
|
*
|
|
* it returns the offset into the file of the first byte of the buffer.
|
|
*
|
|
*/
|
|
|
|
static HB_FOFFSET getblock( PFT_DISPC dispc, HB_FOFFSET offset )
|
|
{
|
|
/*
|
|
set the file pointer to the proper offset
|
|
and if an error occured then check to see
|
|
if a positive offset was requested, if so
|
|
then set the pointer to the offset from
|
|
the end of the file, otherwise set it from
|
|
the beginning of the file.
|
|
*/
|
|
|
|
hb_fsSeekLarge( dispc->infile, offset, FS_SET );
|
|
|
|
/* read in the file and set the buffer bottom variable equal */
|
|
/* to the number of bytes actually read in. */
|
|
|
|
dispc->buffbot = hb_fsReadLarge( dispc->infile, dispc->buffer, dispc->buffsize );
|
|
|
|
/* if a full buffer's worth was not read in, make it full. */
|
|
|
|
if( dispc->buffbot != dispc->buffsize && dispc->fsize > dispc->buffsize )
|
|
{
|
|
if( offset > 0 )
|
|
hb_fsSeekLarge( dispc->infile, -dispc->buffsize, FS_END );
|
|
else
|
|
hb_fsSeekLarge( dispc->infile, dispc->buffsize, FS_SET );
|
|
|
|
dispc->buffbot = hb_fsReadLarge( dispc->infile, dispc->buffer, dispc->buffsize );
|
|
}
|
|
|
|
/* return the actual file position */
|
|
|
|
return hb_fsSeekLarge( dispc->infile, 0, FS_RELATIVE ) - dispc->buffbot;
|
|
}
|
|
|
|
/*
|
|
* buff_align makes sure the buffer top and bottom variables point
|
|
* to actual complete lines of text.
|
|
*
|
|
*/
|
|
|
|
static void buff_align( PFT_DISPC dispc )
|
|
{
|
|
HB_ISIZ i;
|
|
|
|
dispc->bufftop = 0;
|
|
dispc->buffbot = dispc->buffsize;
|
|
|
|
if( dispc->buffoffset != 0 ) /* if the buffoffset is otherthan 0 */
|
|
{
|
|
i = dispc->bufftop; /* start at the top of the file and scan */
|
|
/* forward until a CR is reached. */
|
|
|
|
while( dispc->buffer[ i ] != CR && i < dispc->buffbot )
|
|
i++;
|
|
|
|
dispc->bufftop = i + 2;
|
|
}
|
|
|
|
/* if the buffer offset is not a complete */
|
|
/* buffer's length away from the file end */
|
|
|
|
if( dispc->buffoffset + dispc->buffbot != dispc->fsize )
|
|
{
|
|
/*
|
|
if the file position of the last byte
|
|
of the buffer would end up past the
|
|
end of the file, then the buffer does
|
|
contain a complete buffer full and the
|
|
buffer end pointer needs to be set to
|
|
the last character of the file.
|
|
*/
|
|
|
|
if( dispc->buffoffset + dispc->buffbot > dispc->fsize )
|
|
dispc->buffbot = ( HB_ISIZ ) ( dispc->fsize - dispc->buffoffset );
|
|
|
|
i = dispc->buffbot; /* point the end of the buffer to a valid */
|
|
/* complete text line. */
|
|
|
|
while( dispc->buffer[ i ] != CR && i > dispc->bufftop )
|
|
i--;
|
|
|
|
dispc->buffbot = i + 2;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* win_align takes the value for wintop and then figures out where
|
|
* winbot would be. if winbot would extend past the end of the
|
|
* buffer, then the top of the window is adjusted to ensure that a full
|
|
* screen of text will appear. This simplifies the cursor routines.
|
|
*
|
|
*/
|
|
|
|
static void win_align( PFT_DISPC dispc )
|
|
{
|
|
int i;
|
|
|
|
dispc->winbot = dispc->wintop; /* find out if there is enough text for */
|
|
i = 0; /* full window. */
|
|
|
|
while( dispc->winbot < dispc->buffbot && i < dispc->height )
|
|
{
|
|
if( dispc->buffer[ dispc->winbot ] == CR )
|
|
i++;
|
|
dispc->winbot++;
|
|
}
|
|
|
|
if( i < dispc->height ) /* if there is not a full window, */
|
|
{
|
|
/* then retrofit winbot to the end of a line */
|
|
while( dispc->buffer[ dispc->winbot ] != LF && dispc->winbot > dispc->bufftop )
|
|
dispc->winbot--;
|
|
|
|
dispc->wintop = dispc->winbot;
|
|
i = 0; /* and setup dispc->wintop */
|
|
|
|
while( dispc->wintop > dispc->bufftop && i <= dispc->height )
|
|
{
|
|
if( dispc->buffer[ dispc->wintop ] == LF )
|
|
i++;
|
|
dispc->wintop--;
|
|
}
|
|
|
|
if( dispc->wintop != dispc->bufftop )
|
|
dispc->wintop += 2;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* this routine displays the actual text in the window. This is done
|
|
* by taking each line and placing it in a string. the screen line
|
|
* is then taken from the appropriate group of characters in the string.
|
|
* this allows a window to page left-right across the buffer without
|
|
* having to use any complex algorithm to calc the needed chars.
|
|
*
|
|
*/
|
|
|
|
static void disp_update( PFT_DISPC dispc, int offset )
|
|
{
|
|
int line, col, pos, i;
|
|
|
|
dispc->bRefresh = HB_FALSE;
|
|
line = 0;
|
|
|
|
while( line < dispc->height )
|
|
{
|
|
/*
|
|
calculate the initial position, this save execution
|
|
time because each column is considered as a offset
|
|
from the line start
|
|
*/
|
|
|
|
pos = ( line * ( dispc->width + 1 ) * dispc->iCellSize );
|
|
|
|
/* copy string to temp buffer */
|
|
|
|
for( i = 0; dispc->buffer[ offset ] != CR && offset <= dispc->winbot; offset++ )
|
|
{
|
|
if( i <= dispc->maxlin )
|
|
{
|
|
if( dispc->buffer[ offset ] == '\t' ) /* check for a tab */
|
|
{
|
|
dispc->lbuff[ i++ ] = ' '; /* pad with spaces */
|
|
while( i % TABSET && i <= dispc->maxlin ) /* until tab stop */
|
|
dispc->lbuff[ i++ ] = ' '; /* is reached or EOL */
|
|
}
|
|
else
|
|
dispc->lbuff[ i++ ] = dispc->buffer[ offset ];
|
|
|
|
}
|
|
}
|
|
|
|
for(; i <= dispc->maxlin; i++ ) /* fill out with spaces */
|
|
dispc->lbuff[ i ] = ' ';
|
|
|
|
/* place the proper characters onto the screen */
|
|
|
|
for( i = dispc->wincol, col = 0; col <= dispc->width; col++ )
|
|
{
|
|
HB_UCHAR * vmem = dispc->vseg + pos + ( col * dispc->iCellSize );
|
|
|
|
*vmem = dispc->lbuff[ i++ ];
|
|
}
|
|
|
|
line += 1;
|
|
offset += 2;
|
|
}
|
|
hb_gtRest( dispc->sline, dispc->scol, dispc->eline, dispc->ecol, dispc->vseg );
|
|
}
|
|
|
|
/*
|
|
* move the window pointers so that a new window's worth of information
|
|
* is visible. it adjusts the pointers within the buffer and if necessary
|
|
* it calls the getblock function to load in a new buffer
|
|
*
|
|
*/
|
|
|
|
static void winup( PFT_DISPC dispc )
|
|
{
|
|
int k;
|
|
HB_FOFFSET i, j;
|
|
|
|
dispc->bRefresh = HB_TRUE;
|
|
k = dispc->wintop - 3;
|
|
|
|
while( dispc->buffer[ k ] != CR && k > dispc->bufftop )
|
|
k--;
|
|
|
|
if( k >= dispc->bufftop )
|
|
{
|
|
if( dispc->buffer[ k ] == CR )
|
|
k += 2;
|
|
|
|
dispc->wintop = k;
|
|
k = dispc->winbot - 3;
|
|
|
|
while( dispc->buffer[ k ] != CR )
|
|
k--;
|
|
|
|
dispc->winbot = k + 2;
|
|
}
|
|
else if( dispc->bufftop + dispc->buffoffset > 0 && dispc->fsize > dispc->buffsize )
|
|
{
|
|
i = dispc->buffoffset + dispc->wintop;
|
|
j = dispc->buffoffset - ( dispc->buffsize / 2 );
|
|
|
|
if( j < 0 )
|
|
j = 0;
|
|
|
|
dispc->buffoffset = getblock( dispc, j );
|
|
dispc->wintop = ( int ) ( i - dispc->buffoffset );
|
|
|
|
buff_align( dispc );
|
|
win_align( dispc );
|
|
}
|
|
}
|
|
|
|
/*
|
|
* move the window pointers so that a new window's worth of information
|
|
* is visible. it adjusts the pointers within the buffer and if necessary
|
|
* it calls the getblock function to load in a new buffer
|
|
*
|
|
*/
|
|
|
|
static void windown( PFT_DISPC dispc )
|
|
{
|
|
int k;
|
|
HB_FOFFSET i, j;
|
|
|
|
dispc->bRefresh = HB_TRUE;
|
|
k = dispc->winbot;
|
|
|
|
while( dispc->buffer[ k ] != CR && k <= dispc->buffbot )
|
|
k++;
|
|
k += 2;
|
|
|
|
if( k <= dispc->buffbot )
|
|
{
|
|
dispc->winbot = k;
|
|
k = dispc->wintop;
|
|
|
|
while( dispc->buffer[ k ] != CR )
|
|
k++;
|
|
dispc->wintop = k + 2;
|
|
}
|
|
else if( ( dispc->buffbot + dispc->buffoffset ) < dispc->fsize && dispc->fsize > dispc->buffsize )
|
|
{
|
|
i = dispc->buffoffset + dispc->wintop;
|
|
j = i;
|
|
|
|
if( j > dispc->fsize )
|
|
j = dispc->fsize - dispc->buffsize;
|
|
|
|
dispc->buffoffset = getblock( dispc, j );
|
|
|
|
if( i < dispc->buffoffset )
|
|
dispc->wintop = 0;
|
|
else
|
|
dispc->wintop = ( int ) ( i - dispc->buffoffset );
|
|
|
|
buff_align( dispc );
|
|
win_align( dispc );
|
|
}
|
|
}
|
|
|
|
/* move the cursor one line down */
|
|
|
|
static void linedown( PFT_DISPC dispc )
|
|
{
|
|
if( dispc->winrow < dispc->eline ) /* if cursor not at last line */
|
|
++dispc->winrow;
|
|
else /* otherwise adjust the window top variable */
|
|
windown( dispc );
|
|
}
|
|
|
|
/* move the cursor one line up */
|
|
|
|
static void lineup( PFT_DISPC dispc )
|
|
{
|
|
if( dispc->winrow > dispc->sline )
|
|
--dispc->winrow;
|
|
else
|
|
winup( dispc );
|
|
}
|
|
|
|
/* go to the top of the file */
|
|
|
|
static void filetop( PFT_DISPC dispc )
|
|
{
|
|
if( dispc->buffoffset != 0 )
|
|
{
|
|
dispc->buffoffset = getblock( dispc, 0 );
|
|
|
|
buff_align( dispc );
|
|
}
|
|
|
|
dispc->bRefresh = HB_TRUE;
|
|
dispc->wintop = ( int ) dispc->buffoffset;
|
|
dispc->winrow = dispc->sline;
|
|
dispc->wincol = 0;
|
|
|
|
win_align( dispc );
|
|
}
|
|
|
|
/* goto the bottom of the file */
|
|
|
|
static void filebot( PFT_DISPC dispc )
|
|
{
|
|
if( ( dispc->buffbot + dispc->buffoffset ) < dispc->fsize && dispc->fsize > dispc->buffsize )
|
|
{
|
|
dispc->buffoffset = getblock( dispc, dispc->fsize + 1 );
|
|
|
|
buff_align( dispc );
|
|
}
|
|
|
|
dispc->bRefresh = HB_TRUE;
|
|
dispc->wintop = ( int ) dispc->buffbot - 3;
|
|
dispc->winrow = dispc->eline;
|
|
dispc->wincol = 0;
|
|
|
|
win_align( dispc );
|
|
}
|
|
|
|
HB_FUNC( _FT_DFINIT )
|
|
{
|
|
PFT_DISPC dispc = ( PFT_DISPC ) hb_stackGetTSD( &s_dispc );
|
|
|
|
int rval;
|
|
HB_ISIZ j;
|
|
HB_ISIZ i;
|
|
HB_SIZE nSize;
|
|
|
|
rval = 0;
|
|
|
|
dispc->sline = hb_parni( 2 ); /* top row of window */
|
|
dispc->scol = hb_parni( 3 ); /* left col */
|
|
dispc->eline = hb_parni( 4 ); /* bottom row */
|
|
dispc->ecol = hb_parni( 5 ); /* right col */
|
|
|
|
dispc->width = dispc->ecol - dispc->scol; /* calc width of window */
|
|
dispc->height = dispc->eline - dispc->sline + 1; /* calc height of window */
|
|
|
|
hb_gtRectSize( 0, 0, 0, 0, &nSize );
|
|
|
|
dispc->iCellSize = ( int ) nSize;
|
|
|
|
hb_gtRectSize( dispc->sline, dispc->scol, dispc->eline, dispc->ecol, &nSize );
|
|
dispc->vseg = ( HB_UCHAR * ) hb_xalloc( nSize );
|
|
if( dispc->vseg != NULL )
|
|
hb_gtSave( dispc->sline, dispc->scol, dispc->eline, dispc->ecol, dispc->vseg );
|
|
|
|
dispc->maxlin = hb_parni( 12 );
|
|
dispc->buffsize = hb_parns( 13 ); /* yes - load value */
|
|
|
|
dispc->buffer = ( char * ) hb_xalloc( dispc->buffsize ); /* allocate memory */
|
|
dispc->lbuff = ( char * ) hb_xalloc( dispc->maxlin + 1 ); /* for buffers */
|
|
|
|
dispc->bIsAllocated = ! ( dispc->buffer == NULL || dispc->lbuff == NULL || dispc->vseg == NULL );
|
|
/* memory allocated? */
|
|
if( ! dispc->bIsAllocated )
|
|
{
|
|
rval = 8; /* return error code 8 (memory) */
|
|
if( dispc->buffer != NULL )
|
|
hb_xfree( dispc->buffer );
|
|
if( dispc->lbuff != NULL )
|
|
hb_xfree( dispc->lbuff );
|
|
if( dispc->vseg != NULL )
|
|
hb_xfree( dispc->vseg );
|
|
}
|
|
else /* get parameters */
|
|
{
|
|
dispc->infile = hb_numToHandle( hb_parnint( 1 ) ); /* file handle */
|
|
j = hb_parni( 6 ); /* starting line value */
|
|
dispc->norm = hb_parni( 7 ); /* normal color attribute */
|
|
dispc->hlight = hb_parni( 8 ); /* highlight color attribute */
|
|
|
|
if( HB_ISARRAY( 9 ) )
|
|
{
|
|
dispc->keytype = K_LIST;
|
|
dispc->kcount = hb_parinfa( 9, 0 );
|
|
if( dispc->kcount > 24 )
|
|
dispc->kcount = 24;
|
|
for( i = 1; i <= dispc->kcount; i++ )
|
|
dispc->keylist[ i - 1 ] = hb_parvni( 9, i ); /* get exit key list */
|
|
}
|
|
else
|
|
{
|
|
const char * pszKeys = hb_parcx( 9 );
|
|
dispc->keytype = K_STRING;
|
|
dispc->kcount = hb_parclen( 9 );
|
|
if( dispc->kcount > 24 )
|
|
dispc->kcount = 24;
|
|
for( i = 1; i <= dispc->kcount; i++ )
|
|
dispc->keylist[ i - 1 ] = pszKeys[ i - 1 ]; /* get exit key list */
|
|
}
|
|
|
|
dispc->bBrowse = hb_parl( 10 ); /* get browse flag */
|
|
|
|
dispc->colinc = hb_parni( 11 ); /* column skip value */
|
|
|
|
dispc->bufftop = 0; /* init buffer top pointer */
|
|
dispc->buffbot = dispc->buffsize; /* init buffer bottom pointer */
|
|
dispc->buffoffset = 0; /* curr line offset into buffer */
|
|
dispc->winrow = dispc->sline; /* init window row */
|
|
dispc->wincol = 0; /* init window col */
|
|
dispc->wintop = 0; /* init window top pointer */
|
|
dispc->winbot = 0; /* init window bottom pointer */
|
|
|
|
/* get file size */
|
|
|
|
dispc->fsize = hb_fsSeek( dispc->infile, 0, FS_END ) - 1;
|
|
|
|
/* get the first block */
|
|
|
|
hb_fsSeek( dispc->infile, 0, FS_SET );
|
|
|
|
/* if block less than buffsize */
|
|
|
|
if( dispc->fsize < dispc->buffbot )
|
|
dispc->buffbot = ( int ) dispc->fsize; /* then set buffer bottom */
|
|
|
|
/* set the current lines buffer offset pointer */
|
|
|
|
dispc->buffoffset = getblock( dispc, dispc->bufftop );
|
|
|
|
/* align buffer and window pointer to valid values */
|
|
|
|
buff_align( dispc );
|
|
win_align( dispc );
|
|
|
|
/* point line pointer to line passed by caller */
|
|
|
|
for( i = 1; i < j; i++ )
|
|
linedown( dispc );
|
|
|
|
hb_gtRest( dispc->sline, dispc->scol, dispc->eline, dispc->ecol, dispc->vseg );
|
|
}
|
|
|
|
hb_retni( rval );
|
|
}
|
|
|
|
HB_FUNC( _FT_DFCLOS )
|
|
{
|
|
PFT_DISPC dispc = ( PFT_DISPC ) hb_stackGetTSD( &s_dispc );
|
|
|
|
if( dispc->bIsAllocated )
|
|
{
|
|
if( dispc->buffer != NULL )
|
|
hb_xfree( dispc->buffer ); /* free up allocated buffer memory */
|
|
if( dispc->lbuff != NULL )
|
|
hb_xfree( dispc->lbuff );
|
|
if( dispc->vseg != NULL )
|
|
hb_xfree( dispc->vseg );
|
|
}
|
|
}
|
|
|
|
HB_FUNC( FT_DISPFILE )
|
|
{
|
|
PFT_DISPC dispc = ( PFT_DISPC ) hb_stackGetTSD( &s_dispc );
|
|
|
|
int i;
|
|
char rval[ 2 ];
|
|
HB_BOOL bDone;
|
|
|
|
int ch;
|
|
|
|
/* make sure buffers were allocated and file was opened */
|
|
if( dispc->bIsAllocated && dispc->infile > 0 )
|
|
{
|
|
bDone = HB_FALSE;
|
|
dispc->bRefresh = HB_TRUE;
|
|
|
|
/* draw inside of window with normal color attribute */
|
|
|
|
for( i = 0; i < dispc->height; i++ )
|
|
chattr( dispc, 0, i, dispc->width, dispc->norm );
|
|
|
|
hb_gtRest( dispc->sline, dispc->scol, dispc->eline, dispc->ecol, dispc->vseg );
|
|
|
|
/* main processing loop -- terminated by user key press */
|
|
|
|
do
|
|
{
|
|
if( dispc->bRefresh ) /* redraw window contents? */
|
|
disp_update( dispc, dispc->wintop );
|
|
|
|
hb_gtRest( dispc->sline, dispc->scol, dispc->eline, dispc->ecol, dispc->vseg );
|
|
|
|
/* if not browse, highlight the current line */
|
|
|
|
if( ! dispc->bBrowse )
|
|
chattr( dispc, 0, dispc->winrow - dispc->sline, dispc->width, dispc->hlight );
|
|
|
|
hb_gtRest( dispc->sline, dispc->scol, dispc->eline, dispc->ecol, dispc->vseg );
|
|
|
|
hb_gtSetPos( dispc->winrow, dispc->scol );
|
|
|
|
ch = hb_inkey( HB_TRUE, 0.0, INKEY_ALL );
|
|
|
|
/* if not browse, then un-highlight current line */
|
|
|
|
if( ! dispc->bBrowse )
|
|
chattr( dispc, 0, dispc->winrow - dispc->sline, dispc->width, dispc->norm );
|
|
|
|
hb_gtRest( dispc->sline, dispc->scol, dispc->eline, dispc->ecol, dispc->vseg );
|
|
|
|
/* figure out what the user wants to do */
|
|
|
|
switch( ch )
|
|
{
|
|
case K_DOWN:
|
|
|
|
if( dispc->bBrowse ) /* if browse flag */
|
|
dispc->winrow = dispc->eline; /* is set, force */
|
|
|
|
/* active line to */
|
|
linedown( dispc ); /* be last line */
|
|
break;
|
|
|
|
case K_UP:
|
|
|
|
if( dispc->bBrowse ) /* if browse flag */
|
|
dispc->winrow = dispc->sline; /* is set, force */
|
|
|
|
/* active line to */
|
|
lineup( dispc ); /* be first line */
|
|
break;
|
|
|
|
case K_LEFT:
|
|
|
|
dispc->wincol -= dispc->colinc; /* move cursor */
|
|
dispc->bRefresh = HB_TRUE; /* to the left */
|
|
|
|
if( dispc->wincol < 0 )
|
|
dispc->wincol = 0;
|
|
|
|
break;
|
|
|
|
case K_RIGHT:
|
|
|
|
dispc->wincol += dispc->colinc; /* move cursor */
|
|
dispc->bRefresh = HB_TRUE; /* to the right */
|
|
|
|
if( dispc->wincol > ( dispc->maxlin - dispc->width ) )
|
|
dispc->wincol = dispc->maxlin - dispc->width;
|
|
|
|
break;
|
|
|
|
case K_HOME:
|
|
|
|
dispc->wincol = 0; /* move cursor */
|
|
dispc->bRefresh = HB_TRUE; /* to first col */
|
|
|
|
break;
|
|
|
|
/* move cursor to last col */
|
|
|
|
case K_END:
|
|
|
|
dispc->wincol = dispc->maxlin - dispc->width;
|
|
dispc->bRefresh = HB_TRUE;
|
|
|
|
break;
|
|
|
|
case K_CTRL_LEFT:
|
|
|
|
dispc->wincol -= 16; /* move cursor */
|
|
dispc->bRefresh = HB_TRUE; /* 16 col to left */
|
|
|
|
if( dispc->wincol < 0 )
|
|
dispc->wincol = 0;
|
|
|
|
break;
|
|
|
|
case K_CTRL_RIGHT:
|
|
|
|
dispc->wincol += 16; /* move cursor */
|
|
dispc->bRefresh = HB_TRUE; /* 16 col to right */
|
|
|
|
if( dispc->wincol > ( dispc->maxlin - dispc->width ) )
|
|
dispc->wincol = dispc->maxlin - dispc->width;
|
|
|
|
break;
|
|
|
|
case K_PGUP:
|
|
|
|
for( i = 0; i < dispc->height; i++ ) /* move window */
|
|
winup( dispc ); /* up one page */
|
|
|
|
break;
|
|
|
|
case K_PGDN:
|
|
|
|
for( i = 0; i < dispc->height; i++ ) /* move window */
|
|
windown( dispc ); /* down 1 page */
|
|
|
|
break;
|
|
|
|
case K_CTRL_PGUP:
|
|
|
|
filetop( dispc ); /* move cursor to */
|
|
break; /* to top of file */
|
|
|
|
case K_CTRL_PGDN:
|
|
|
|
filebot( dispc ); /* move cursor to */
|
|
break; /* to bot of file */
|
|
|
|
case K_ENTER:
|
|
|
|
bDone = HB_TRUE; /* carriage return */
|
|
break; /* terminates */
|
|
|
|
case K_ESC:
|
|
|
|
bDone = HB_TRUE; /* escape key */
|
|
break; /* terminates */
|
|
|
|
/* scan key list and see if key pressed is there */
|
|
|
|
default:
|
|
|
|
for( i = 0; i < dispc->kcount; i++ )
|
|
{
|
|
if( dispc->keylist[ i ] == ch )
|
|
bDone = HB_TRUE;
|
|
}
|
|
}
|
|
}
|
|
while( ! bDone );
|
|
}
|
|
else
|
|
ch = 0;
|
|
|
|
/* store the key pressed as a character to be returned */
|
|
|
|
/* return key value to caller */
|
|
|
|
if( dispc->keytype == K_STRING )
|
|
{
|
|
rval[ 0 ] = ( char ) ch;
|
|
rval[ 1 ] = '\0';
|
|
hb_retc( rval );
|
|
}
|
|
else
|
|
hb_retni( ch );
|
|
}
|