fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
321df92cbe82a0d4e2b2ee04df4cfdce176595df
harbour-core/contrib/hbnf/dispc.c
Viktor Szakats b414d00664 2013-04-05 16:24 UTC+0200 Viktor Szakats (harbour syenar.net) 
* bin/check.hb
  * tests/fixcase.hb
    + some exceptions for casing
    * deleted one file exception (a readme)

  * contrib/gtwvg/gtwvgd.c
  * contrib/gtwvg/wvgcore.c
  * contrib/gtwvg/wvgcuig.c
  * contrib/gtwvg/wvgwin.c
  * contrib/gtwvg/wvgwing.c
  * contrib/hbamf/amfenc.c
  * contrib/hbbz2/core.c
  * contrib/hbct/ctcom1.c
  * contrib/hbct/ctcom2.c
  * contrib/hbct/ctnet.c
  * contrib/hbct/ctstr.c
  * contrib/hbct/ctwfunc.c
  * contrib/hbct/ctwin.c
  * contrib/hbct/disk.c
  * contrib/hbct/finan.c
  * contrib/hbct/screen2.c
  * contrib/hbct/token1.c
  * contrib/hbct/token2.c
  * contrib/hbct/trig.c
  * contrib/hbgd/gdwrp.c
  * contrib/hbhpdf/image.c
  * contrib/hbmisc/irm.c
  * contrib/hbnetio/netiocli.c
  * contrib/hbnetio/netiosrv.c
  * contrib/hbnetio/readme.txt
  * contrib/hbnf/dispc.c
  * contrib/hbnf/ftattr.c
  * contrib/hbnf/origin.c
  * contrib/hbssl/ssl.c
  * contrib/hbwin/wapi_commctrl.c
  * contrib/hbwin/wapi_winuser.c
  * contrib/hbwin/win_dlg.c
  * contrib/hbwin/win_prn2.c
  * contrib/hbwin/win_shell.c
  * contrib/rddads/ads1.c
  * contrib/rddads/adsfunc.c
  * contrib/xhb/fparse.c
  * contrib/xhb/hbcrypt.c
  * contrib/xhb/hbserv.c
  * contrib/xhb/hbxml.c
  * contrib/xhb/txtline.c
  * contrib/xhb/xhbarr.c
  * contrib/xhb/xhbarrex.c
  * extras/gfspell/spellc.c
  * extras/gtwvw/gtwvwd.c
  * extras/gtwvw/hbgtwvw.h
  * extras/gtwvw/wvwcheck.c
  * extras/gtwvw/wvwdraw.c
  * extras/gtwvw/wvwedit.c
  * extras/gtwvw/wvwfuncs.c
  * extras/gtwvw/wvwmenu.c
  * extras/gtwvw/wvwpush.c
  * extras/gtwvw/wvwstbar.c
  * extras/gtwvw/wvwtbar.c
  * include/hbapi.h
  * include/hbapirdd.h
  * include/hbdefs.h
  * include/hbexpra.c
  * include/hbexprb.c
  * include/hbpcode.h
  * include/hbpp.h
  * include/hbrddcdx.h
  * include/hbrddnsx.h
  * src/codepage/cp_utf8.c
  * src/common/expropt1.c
  * src/common/expropt2.c
  * src/compiler/cmdcheck.c
  * src/compiler/genc.c
  * src/compiler/gencc.c
  * src/compiler/hbfunchk.c
  * src/compiler/hbopt.c
  * src/pp/pplib.c
  * src/rdd/dbcmd.c
  * src/rdd/dbf1.c
  * src/rdd/dbfcdx/dbfcdx1.c
  * src/rdd/hbsix/sxcompr.c
  * src/rdd/hbsix/sxord.c
  * src/rdd/hsx/hsx.c
  * src/rtl/chruni.c
  * src/rtl/cputime.c
  * src/rtl/dateshb.c
  * src/rtl/filehb.c
  * src/rtl/filesys.c
  * src/rtl/gtsln/gtsln.c
  * src/rtl/gtwvt/gtwvt.c
  * src/rtl/gtxwc/gtxwc.c
  * src/rtl/hbgtcore.c
  * src/rtl/hbinet.c
  * src/rtl/hblpphb.c
  * src/rtl/hbmd5.c
  * src/rtl/hbproces.c
  * src/rtl/hbsocket.c
  * src/rtl/hbsockhb.c
  * src/rtl/hbtoken.c
  * src/rtl/hbzlib.c
  * src/rtl/hbzlibgz.c
  * src/rtl/langapi.c
  * src/rtl/mlcfunc.c
  * src/rtl/philes.c
  * src/rtl/soundex.c
  * src/rtl/strzero.c
  * src/rtl/transfrm.c
  * src/vm/arrayshb.c
  * src/vm/classes.c
  * src/vm/dynsym.c
  * src/vm/eval.c
  * src/vm/garbage.c
  * src/vm/hvm.c
  * src/vm/macro.c
  * src/vm/memvars.c
  * src/vm/runner.c
  * src/vm/set.c
  * src/vm/thread.c
    * run tests/fixcase.hb now that it's able to fixup casing
      inside all comments
2013-04-05 16:27:40 +02:00

815 lines
25 KiB
C
Raw Blame History

/*
* 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 );
}
Reference in New Issue View Git Blame Copy Permalink