/*
 * $Id$
 */

/*
   Harbour Project source code

   Console management

   Copyright 1999  Antonio Linares <alinares@fivetech.com>
   www - http://www.harbour-project.org

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version, with one exception:

   The exception is that if you link the Harbour Runtime Library (HRL)
   and/or the Harbour Virtual Machine (HVM) with other files to produce
   an executable, this does not by itself cause the resulting executable
   to be covered by the GNU General Public License. Your use of that
   executable is in no way restricted on account of linking the HRL
   and/or HVM code into it.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA (or visit
   their web site at http://www.gnu.org/).
*/

/* Harbour Project source code
   http://www.Harbour-Project.org/

   The following functions are Copyright 1999 Eddie Runia <eddie@runia.com>:
      __ACCEPT()

   The following functions are Copyright 1999 David G. Holm <dholm@jsd-llc.com>:
      adjust_pos(), hb_altout(), hb_devout(), HB_DEVOUT(), hb_devpos(),
      HB_DEVPOS(), hb_dispout(), HB___EJECT(), hb_max_col(), HB_MAXCOL(),
      hb_max_row(), HB_MAXROW(), hb_out(), hb_outerr(), HB_OUTERR(),
      hb_outstd(), HB_OUTSTD(), HB_PCOL(), HB_PROW(), hb_setpos(),
      HB_SETPOS(), HB_SETPRC(), HB_SCROLL(), and hb_consoleInitialize().

   The following functions are Copyright 1999 Victor Szel <info@szelvesz.hu>:
      HB_SETPOSBS()
      HB_DISPBOX() GT version.
      HB_DISPBEGIN()
      HB_DISPEND()
      HB_DISPCOUNT()
      HB_ISCOLOR()
      HB_NOSNOW()
      HB___COLORINDEX().

   See doc/hdr_tpl.txt, Version 1.2 or later, for licensing terms.
*/

#include "extend.h"
#include "itemapi.h"
#include "errorapi.h"
#include "filesys.h"
#include "dates.h"
#include "set.h"
#include "inkey.h"
#include "gtapi.h"            /* HARBOUR_USE_GTAPI is checked inside gtapi.h, so that
                                 we can always get the border styles */

#if defined(__GNUC__) && ! defined(__MINGW32__)
   #include <unistd.h>
   #if defined(__DJGPP__) || defined(__CYGWIN__) || defined(HARBOUR_GCC_OS2)
      #include <io.h>
   #endif
#else
   #include <io.h>
#endif

#if defined(OS_UNIX_COMPATIBLE) || defined(__CYGWIN__)
   #include <unistd.h>
   #include <termios.h>
#endif

#define ACCEPT_BUFFER_LEN 256 /*length of input buffer for ACCEPT command */

#if defined(OS_UNIX_COMPATIBLE)
   #define CRLF_BUFFER_LEN 2     /*length of buffer for CR/LF characters */
#else
   #define CRLF_BUFFER_LEN 3     /*length of buffer for CR/LF characters */
#endif

static USHORT s_uiDevRow;
static USHORT s_uiDevCol;
static USHORT s_uiPRow;
static USHORT s_uiPCol;
static char   s_szCrLf[ CRLF_BUFFER_LEN ];

void hb_consoleRelease( void )
{
#ifdef HARBOUR_USE_GTAPI
   hb_gtExit();
#endif
}

void hb_consoleInitialize( void )
{
#if defined(OS_DOS_COMPATIBLE)
   s_szCrLf[ 0 ] = '\r';
   s_szCrLf[ 1 ] = '\n';
   s_szCrLf[ 2 ] = '\0';
#else
   s_szCrLf[ 0 ] = '\n';
   s_szCrLf[ 1 ] = '\0';
#endif

   s_uiPRow = s_uiPCol = 0;

   /* Some compilers open stdout and stderr in text mode, but
      Harbour needs them to be open in binary mode. */

   hb_fsSetDevMode( fileno( stdout ), FM_BINARY );
   hb_fsSetDevMode( fileno( stderr ), FM_BINARY );

#ifdef HARBOUR_USE_GTAPI
   hb_gtInit();
   hb_gtGetPos( &s_uiDevRow, &s_uiDevCol );
#else
   s_uiDevRow = 0;
   s_uiDevCol = 0;
#endif
}

char * hb_consoleGetNewLine( void )
{
   return s_szCrLf;
}

WORD hb_max_row( void )
{
#ifdef HARBOUR_USE_GTAPI
   return hb_gtMaxRow();
#else
   return 23; /* QUESTION: Shouldn't this be 24 ? info@szelvesz.hu */
#endif        /* ANSWER  : No. ANSI terminals commonly only have 24 lines */
}

WORD hb_max_col( void )
{
#ifdef HARBOUR_USE_GTAPI
   return hb_gtMaxCol();
#else
   return 79;
#endif
}

#ifndef HARBOUR_USE_GTAPI
static void adjust_pos( char * pStr, ULONG len, WORD * row, WORD * col, WORD max_row, WORD max_col )
{
   ULONG count;
   char * pPtr = pStr;

   for( count = 0; count < len; count++ )
   {
      switch( *pPtr++  )
      {
         case 7:
            break;
         case 8:
            if( *col ) ( *col )--;
            else
            {
               *col = max_col;
               if( *row ) ( *row )--;
            }
            break;
         case 10:
            if( *row < max_row ) ( *row )++;
            break;
         case 13:
            *col = 0;
            break;
         default:
            if( *col < max_col ) ( *col )++;
            else
            {
               *col = 0;
               if( *row < max_row ) ( *row )++;
            }
      }
   }
}
#endif

typedef void hb_out_func_typedef( char *, ULONG );

/* Format items for output, then call specified output function */
static void hb_out( WORD wParam, hb_out_func_typedef * hb_out_func )
{
   char * szText;
   PHB_ITEM pItem = hb_param( wParam, IT_ANY );

   switch( pItem->type )
   {
      case IT_STRING:
         hb_out_func( hb_parc( wParam ), hb_parclen( wParam ) );
         break;

      case IT_DATE:
      {
         char szBuffer[ 11 ];
         szText = hb_dtoc( hb_pards( wParam ), szBuffer, hb_set.HB_SET_DATEFORMAT );
         if( szText )
             hb_out_func( szText, strlen( szText ) );
         break;
      }

      case IT_DOUBLE:
      case IT_INTEGER:
      case IT_LONG:
         szText = hb_itemStr( pItem, NULL, NULL ); /* Let hb_itemStr() do the hard work */
         if( szText )
         {
            hb_out_func( szText, strlen( szText ) );
            hb_xfree( szText );
         }
         break;

      case IT_NIL:
         hb_out_func( "NIL", 3 );
         break;

      case IT_LOGICAL:
         if( hb_parl( wParam ) )
            hb_out_func( ".T.", 3 );
         else
            hb_out_func( ".F.", 3 );
         break;

      default:
         break;
   }
}

/* Output an item to STDOUT */
static void hb_outstd( char * pStr, ULONG len )
{
   ULONG count = len;
   char * pPtr = pStr;

#ifdef HARBOUR_USE_GTAPI
   hb_gtPreExt();
#endif

   if( strlen( pStr ) != count )
      while( count-- ) printf( "%c", *pPtr++ );
   else
      printf( "%s", pStr );
   fflush( stdout );
#ifdef HARBOUR_USE_GTAPI
   #ifndef __CYGWIN__
   if( isatty( fileno( stdout ) ) )
   #endif
   {
      s_uiDevRow = hb_gt_Row();
      s_uiDevCol = hb_gt_Col();
      hb_gtSetPos( s_uiDevRow, s_uiDevCol );
   }
   hb_gtPostExt();
#else
   adjust_pos( pStr, len, &s_uiDevRow, &s_uiDevCol, hb_max_row(), hb_max_col() );
#endif
}

/* Output an item to STDERR */
static void hb_outerr( char * pStr, ULONG len )
{
   ULONG count = len;
   char * pPtr = pStr;

#ifdef HARBOUR_USE_GTAPI
   hb_gtPreExt();
#endif

   if( strlen( pStr ) != count )
      while( count-- ) fprintf( stderr, "%c", *pPtr++ );
   else
      fprintf( stderr, "%s", pStr );
   fflush( stderr );
#ifdef HARBOUR_USE_GTAPI
   #ifndef __CYGWIN__
   if( isatty( fileno( stderr ) ) )
   #endif
   {
      s_uiDevRow = hb_gt_Row();
      s_uiDevCol = hb_gt_Col();
      hb_gtSetPos( s_uiDevRow, s_uiDevCol );
   }
   hb_gtPostExt();
#else
   adjust_pos( pStr, len, &s_uiDevRow, &s_uiDevCol, hb_max_row(), hb_max_col() );
#endif
}

/* Output an item to the screen and/or printer and/or alternate */
static void hb_altout( char * pStr, ULONG len )
{
   char *pPtr = pStr;

   if( hb_set.HB_SET_CONSOLE )
   {
#ifdef HARBOUR_USE_GTAPI
      hb_gtWriteCon( pStr, len );
      hb_gtGetPos( &s_uiDevRow, &s_uiDevCol );
#else
      ULONG count = len;
      if( strlen( pStr ) != count )
         while( count-- ) printf( "%c", *pPtr++ );
      else
         printf( "%s", pStr );
      adjust_pos( pStr, len, &s_uiDevRow, &s_uiDevCol, hb_max_row(), hb_max_col() );
#endif
   }
   if( hb_set.HB_SET_ALTERNATE && hb_set_althan >= 0 )
   {
      /* Print to alternate file if SET ALTERNATE ON and valid alternate file */
      int user_ferror = hb_fsError(); /* Save current user file error code */
      unsigned write_len;
      ULONG count = len;
      pPtr = pStr;
      while( count )
      {
         if( count > UINT_MAX )
         {
            write_len = UINT_MAX;
            count -= UINT_MAX;
         }
         else
         {
            write_len = count;
            count = 0;
         }
         hb_fsWrite( hb_set_althan, ( BYTE * ) pPtr, write_len );
         pPtr += write_len;
      }
      hb_fsSetError( user_ferror ); /* Restore last user file error code */
   }
   if( hb_set_extrahan >= 0 )
   {
      /* Print to extra file if valid alternate file */
      int user_ferror = hb_fsError(); /* Save current user file error code */
      unsigned write_len;
      ULONG count = len;
      pPtr = pStr;
      while( count )
      {
         if( count > UINT_MAX )
         {
            write_len = UINT_MAX;
            count -= UINT_MAX;
         }
         else
         {
            write_len = count;
            count = 0;
         }
         hb_fsWrite( hb_set_extrahan, ( BYTE * ) pPtr, write_len );
         pPtr += write_len;
      }
      hb_fsSetError( user_ferror ); /* Restore last user file error code */
   }
   if( hb_set.HB_SET_PRINTER && hb_set_printhan >= 0 )
   {
      /* Print to printer if SET PRINTER ON and valid printer file */
      int user_ferror = hb_fsError(); /* Save current user file error code */
      unsigned write_len;
      ULONG count = len;
      pPtr = pStr;
      while( count )
      {
         if( count > UINT_MAX )
         {
            write_len = UINT_MAX;
            count -= UINT_MAX;
         }
         else
         {
            write_len = count;
            count = 0;
         }
         hb_fsWrite( hb_set_printhan, ( BYTE * ) pPtr, write_len );
         pPtr += write_len;
      }
      if( len + s_uiPCol > USHRT_MAX ) s_uiPCol = USHRT_MAX;
      else s_uiPCol += len;
      hb_fsSetError( user_ferror ); /* Restore last user file error code */
   }
}

/* Output an item to the screen and/or printer */
static void hb_devout( char * pStr, ULONG len )
{
   if( hb_set_printhan >= 0 && hb_stricmp( hb_set.HB_SET_DEVICE, "PRINTER" ) == 0 )
   {
      /* Display to printer if SET DEVICE TO PRINTER and valid printer file */
      int user_ferror = hb_fsError(); /* Save current user file error code */
      unsigned write_len;
      ULONG count = len;
      char * pPtr = pStr;
      while( count )
      {
         if( count > UINT_MAX )
         {
            write_len = UINT_MAX;
            count -= UINT_MAX;
         }
         else
         {
            write_len = count;
            count = 0;
         }
         hb_fsWrite( hb_set_printhan, ( BYTE * ) pPtr, write_len );
         pPtr += write_len;
      }
      if( len + s_uiPCol > USHRT_MAX ) s_uiPCol = USHRT_MAX;
      else s_uiPCol += len;
      hb_fsSetError( user_ferror ); /* Restore last user file error code */
   }
   else
   {
#ifdef HARBOUR_USE_GTAPI
      /* Otherwise, display to console */
      hb_gtWrite( pStr, len );
      hb_gtGetPos( &s_uiDevRow, &s_uiDevCol );
#else
      ULONG count = len;
      char * pPtr = pStr;
      if( strlen( pStr ) != count )
         while( count-- ) printf( "%c", *pPtr++ );
      else
         printf( "%s", pStr );
      adjust_pos( pStr, len, &s_uiDevRow, &s_uiDevCol, hb_max_row(), hb_max_col() );
#endif
   }
}

/* Output an item to the screen */
static void hb_dispout( char * pStr, ULONG len )
{
#ifdef HARBOUR_USE_GTAPI
   /* Display to console */
   hb_gtWrite( pStr, len );
   hb_gtGetPos( &s_uiDevRow, &s_uiDevCol );
#else
   ULONG count = len;
   char * pPtr = pStr;
   if( strlen( pStr ) != count )
      while( count-- ) printf( "%c", *pPtr++ );
   else
      printf( "%s", pStr );
   adjust_pos( pStr, len, &s_uiDevRow, &s_uiDevCol, hb_max_row(), hb_max_col() );
#endif
}

void hb_setpos( WORD row, WORD col )
{
#ifdef HARBOUR_USE_GTAPI
      hb_gtSetPos( row, col );
#else
      WORD count;

      if( row < s_uiDevRow || col < s_uiDevCol )
      {
         printf( s_szCrLf );
         s_uiDevCol = 0;
         s_uiDevRow++;
      }
      else if( row > s_uiDevRow ) s_uiDevCol = 0;
      for( count = s_uiDevRow; count < row; count++ ) printf( s_szCrLf );
      for( count = s_uiDevCol; count < col; count++ ) printf( " " );
#endif

   s_uiDevRow = row;
   s_uiDevCol = col;
}

void hb_devpos( WORD row, WORD col )
{
   WORD count;
   /* Position printer if SET DEVICE TO PRINTER and valid printer file
      otherwise position console */
   if( hb_set_printhan >= 0 && hb_stricmp( hb_set.HB_SET_DEVICE, "PRINTER" ) == 0 )
   {
      int user_ferror = hb_fsError(); /* Save current user file error code */
      if( row < s_uiPRow )
      {
         hb_fsWrite( hb_set_printhan, ( BYTE * ) "\x0C", 1 );
         s_uiPRow = s_uiPCol = 0;
      }

      for( count = s_uiPRow; count < row; count++ )
         hb_fsWrite( hb_set_printhan, ( BYTE * ) s_szCrLf, CRLF_BUFFER_LEN-1 );

      if( row > s_uiPRow ) s_uiPCol = 0;
      col += hb_set.HB_SET_MARGIN;

      for( count = s_uiPCol; count < col; count++ )
         hb_fsWrite( hb_set_printhan, ( BYTE * ) " ", 1 );

      s_uiPRow = row;
      s_uiPCol = col;
      hb_fsSetError( user_ferror ); /* Restore last user file error code */
   }
   else
   {
      hb_setpos( row, col );
   }
}

HARBOUR HB_OUTSTD( void ) /* writes a list of values to the standard output device */
{
   WORD w, pcount = hb_pcount();

   for( w = 1; w <= pcount; w++ )
   {
      hb_out( w, hb_outstd );
      if( w < pcount ) hb_outstd( " ", 1 );
   }
}

HARBOUR HB_OUTERR( void ) /* writes a list of values to the standard error device */
{
   WORD w, pcount = hb_pcount();

   for( w = 1; w <= pcount; w++ )
   {
      hb_out( w, hb_outerr );
      if( w < pcount ) hb_outerr( " ", 1 );
   }
}

HARBOUR HB_QQOUT( void ) /* writes a list of values to the current device (screen or printer) and is affected by SET ALTERNATE */
{
   WORD w, pcount = hb_pcount();

   for( w = 1; w <= pcount; w++ )
   {
      hb_out( w, hb_altout );
      if( w < pcount ) hb_altout( " ", 1 );
   }
}

HARBOUR HB_QOUT( void )
{
   WORD count;

   hb_altout( s_szCrLf, CRLF_BUFFER_LEN - 1 );

   if( hb_set.HB_SET_PRINTER && hb_set_printhan >= 0 )
   {
      int user_ferror = hb_fsError(); /* Save current user file error code */
      s_uiPRow++;
      s_uiPCol = hb_set.HB_SET_MARGIN;
      count = s_uiPCol;
      while( count-- > 0 )
         hb_fsWrite( hb_set_printhan, ( BYTE * ) " ", 1 );
      hb_fsSetError( user_ferror ); /* Restore last user file error code */
   }

   HB_QQOUT();
}

HARBOUR HB_SETPOS( void ) /* Sets the screen position */
{
   if( hb_pcount() == 2 )
   {
      if( ISNUM( 1 ) && ISNUM( 2 ) )
      {
         int i_row = hb_parni( 1 );
         int i_col = hb_parni( 2 );
         WORD row, col;

         /* Limit the new position to the range (0,0) to (MAXROW(),MAXCOL()) */
         if( i_row < 0 ) row = 0;
         else if( i_row > hb_max_row() ) row = hb_max_row();
         else row = i_row;

         if( i_col < 0 ) col = 0;
         else if( i_col > hb_max_col() ) col = hb_max_col();
         else col = i_col;

         /* Set the new screen position */
         hb_setpos( row, col );
      }
   }
   else
      hb_errRT_BASE( EG_ARGCOUNT, 3000, NULL, "SETPOS" ); /* NOTE: Clipper catches this at compile time! */
}

/* Move the screen position to the right by one column */
HARBOUR HB_SETPOSBS( void )
{
   if( hb_pcount() == 0 )
   {
      USHORT uiRow;
      USHORT uiCol;

      /* NOTE: Clipper does no checks about reaching the border or anything */
#ifdef HARBOUR_USE_GTAPI
      hb_gtGetPos( &uiRow, &uiCol );
      hb_gtSetPos( uiRow, uiCol + 1 );
#endif
   }
   else
      hb_errRT_BASE( EG_ARGCOUNT, 3000, NULL, "SETPOSBS" ); /* NOTE: Clipper catches this at compile time! */
}

HARBOUR HB_DEVPOS( void ) /* Sets the screen and/or printer position */
{
   if( hb_pcount() == 2 )
   {
      if( ISNUM( 1 ) && ISNUM( 2 ) )
      {
         long l_row = hb_parnl( 1 );
         long l_col = hb_parnl( 2 );
         WORD row, col;

         /* Limit the new position to the range (0,0) to (65535,65535) */
         if( l_row < 0 ) row = 0;
         else if( l_row > USHRT_MAX ) row = USHRT_MAX;
         else row = l_row;

         if( l_col < 0 ) col = 0;
         else if( l_col > USHRT_MAX ) col = USHRT_MAX;
         else col = l_col;

         /* Set the new screen position */
         hb_devpos( row, col );
      }
   }
   else
      hb_errRT_BASE( EG_ARGCOUNT, 3000, NULL, "DEVPOS" ); /* NOTE: Clipper catches this at compile time! */
}

HARBOUR HB_DEVOUT( void ) /* writes a single value to the current device (screen or printer), but is not affected by SET ALTERNATE */
{
   if( hb_pcount() > 0 )
   {
#ifdef HARBOUR_USE_GTAPI
      char pOldColor[ CLR_STRLEN ];

      if( ISCHAR( 2 ) )
      {
         hb_gtGetColorStr( pOldColor );
         hb_gtSetColorStr( hb_parc( 2 ) );
      }
#endif

      hb_out( 1, hb_devout );

#ifdef HARBOUR_USE_GTAPI
      if( ISCHAR( 2 ) )
         hb_gtSetColorStr( pOldColor );
#endif
   }
}

HARBOUR HB_DISPOUT( void ) /* writes a single value to the current device (screen or printer), but is not affected by SET ALTERNATE */
{
   if( hb_pcount() > 0 )
   {
#ifdef HARBOUR_USE_GTAPI
      char pOldColor[ CLR_STRLEN ];

      if( ISCHAR( 2 ) )
      {
         hb_gtGetColorStr( pOldColor );
         hb_gtSetColorStr( hb_parc( 2 ) );
      }
#endif

      hb_out( 1, hb_dispout );

#ifdef HARBOUR_USE_GTAPI
      if( ISCHAR( 2 ) )
         hb_gtSetColorStr( pOldColor );
#endif
   }
}

HARBOUR HB___EJECT( void ) /* Ejects the current page from the printer */
{
   if( hb_stricmp( hb_set.HB_SET_DEVICE, "PRINTER" ) == 0 && hb_set_printhan >= 0 )
   {
      int user_ferror = hb_fsError(); /* Save current user file error code */
      hb_fsWrite( hb_set_printhan, ( BYTE * ) "\x0C\x0D", 2 );
      s_uiPRow = s_uiPCol = 0;
      hb_fsSetError( user_ferror ); /* Restore last user file error code */
   }
}

HARBOUR HB_PROW( void ) /* Returns the current printer row position */
{
   if( hb_pcount() == 0 )
      hb_retni( s_uiPRow );
   else
      hb_errRT_BASE( EG_ARGCOUNT, 3000, NULL, "PROW" ); /* NOTE: Clipper catches this at compile time! */
}

HARBOUR HB_PCOL( void ) /* Returns the current printer row position */
{
   if( hb_pcount() == 0 )
      hb_retni( s_uiPCol );
   else
      hb_errRT_BASE( EG_ARGCOUNT, 3000, NULL, "PCOL" ); /* NOTE: Clipper catches this at compile time! */
}

HARBOUR HB_SETPRC( void ) /* Sets the current printer row and column positions */
{
   if( ISNUM( 1 ) && ISNUM( 2 ) )
   {
      long l_row = hb_parnl( 1 );
      long l_col = hb_parnl( 2 );

      /* Limit the new position to the range (0,0) to (65535,65535) */

      if( l_row < 0 ) s_uiPRow = 0;
      else if( l_row > USHRT_MAX ) s_uiPRow = USHRT_MAX;
      else s_uiPRow = l_row;

      if( l_col < 0 ) s_uiPCol = 0;
      else if( l_col > USHRT_MAX ) s_uiPCol = USHRT_MAX;
      else s_uiPCol = l_col;
   }
}

HARBOUR HB_SCROLL( void ) /* Scrolls a screen region (requires the GT API) */
{
   WORD top, left, bottom, right;

   int iMR      = hb_max_row();
   int iMC      = hb_max_col();

   int i_top    = ISNUM( 1 ) ? hb_parni( 1 ) : 0;
   int i_left   = ISNUM( 2 ) ? hb_parni( 2 ) : 0;
   int i_bottom = ISNUM( 3 ) ? hb_parni( 3 ) : iMR;
   int i_right  = ISNUM( 4 ) ? hb_parni( 4 ) : iMC;
   int v_scroll = ISNUM( 5 ) ? hb_parni( 5 ) : 0;
   int h_scroll = ISNUM( 6 ) ? hb_parni( 6 ) : 0;

   /* Enforce limits of (0,0) to (MAXROW(),MAXCOL()) */
   if( i_top < 0 ) top = 0;
   else if( i_top > iMR ) top = iMR;
   else top = i_top;
   if( i_left < 0 ) left = 0;
   else if( i_left > iMC ) left = iMC;
   else left = i_left;
   if( i_bottom < 0 ) bottom = 0;
   else if( i_bottom > iMR ) bottom = iMR;
   else bottom = i_bottom;
   if( i_right < 0 ) right = 0;
   else if( i_right > iMC ) right = iMC;
   else right = i_right;

#ifdef HARBOUR_USE_GTAPI
   hb_gtScroll( top, left, bottom, right, v_scroll, h_scroll );
#else
   if( top == 0 && bottom == iMR
   && left == 0 && right == iMC
   && v_scroll == 0 && h_scroll == 0 )
   {
      WORD count;
      s_uiDevRow = iMR;
      for( count = 0; count < s_uiDevRow ; count++ ) printf( s_szCrLf );
      s_uiDevRow = s_uiDevCol = 0;
   }
#endif
}

HARBOUR HB_MAXROW( void ) /* Return the maximum screen row number (zero origin) */
{
   hb_retni( hb_max_row() );
}

HARBOUR HB_MAXCOL( void ) /* Return the maximum screen column number (zero origin) */
{
   hb_retni( hb_max_col() );
}

HARBOUR HB_ROW( void ) /* Return the current screen row position (zero origin) */
{
   if( hb_pcount() == 0 )
   {
#ifdef HARBOUR_USE_GTAPI
      hb_gtGetPos( &s_uiDevRow, &s_uiDevCol );
#endif
      hb_retni( s_uiDevRow );
   }
   else
      hb_errRT_BASE( EG_ARGCOUNT, 3000, NULL, "ROW" ); /* NOTE: Clipper catches this at compile time! */
}

HARBOUR HB_COL( void ) /* Return the current screen column position (zero origin) */
{
   if( hb_pcount() == 0 )
   {
#ifdef HARBOUR_USE_GTAPI
      hb_gtGetPos( &s_uiDevRow, &s_uiDevCol );
#endif
      hb_retni( s_uiDevCol );
   }
   else
      hb_errRT_BASE( EG_ARGCOUNT, 3000, NULL, "COL" ); /* NOTE: Clipper catches this at compile time! */
}

HARBOUR HB_DISPBOX( void )
{
#ifdef HARBOUR_USE_GTAPI
   if( ISNUM( 1 ) && ISNUM( 2 ) && ISNUM( 3 ) && ISNUM( 4 ) )
   {
      char szOldColor[ CLR_STRLEN ];

      if( ISCHAR( 6 ) )
      {
         hb_gtGetColorStr( szOldColor );
         hb_gtSetColorStr( hb_parc( 6 ) );
      }

      if( ISCHAR( 5 ) )
         hb_gtBox( hb_parni( 1 ), hb_parni( 2 ), hb_parni( 3 ), hb_parni( 4 ), hb_parc( 5 ));
      else if( ISNUM( 5 ) && hb_parni( 5 ) == 2 )
         hb_gtBoxD( hb_parni( 1 ), hb_parni( 2 ), hb_parni( 3 ), hb_parni( 4 ) );
      else
         hb_gtBoxS( hb_parni( 1 ), hb_parni( 2 ), hb_parni( 3 ), hb_parni( 4 ) );

      if( ISCHAR( 6 ) )
         hb_gtSetColorStr( szOldColor );
   }
#else
   if( ISNUM( 1 ) && ISNUM( 2 ) && ISNUM( 3 ) && ISNUM( 4 ) )
   {
      char * szBorderStyle = B_SINGLE;
      int i_top = hb_parni( 1 ), i_left = hb_parni( 2 );
      int i_bottom = hb_parni( 3 ), i_right = hb_parni( 4 );
      WORD top, left, bottom, right, size = strlen( B_SINGLE );
      WORD row, col, width, height;
      char Borders[ 9 ];

      /* Set limits on the box coordinates to (0,0) and (max_row(),max_col()) */
      if( i_top < 0 ) top = 0; else top = ( WORD ) i_top;
      if( i_left < 0 ) left = 0; else left = ( WORD ) i_left;
      if( i_bottom < 0 ) bottom  = 0; else bottom = ( WORD ) i_bottom;
      if( i_right < 0 ) right = 0; else right = ( WORD ) i_right;
      if( top > hb_max_row() ) top = hb_max_row();
      if( left > hb_max_col() ) left = hb_max_col();
      if( bottom > hb_max_row() ) bottom  = hb_max_row();
      if( right > hb_max_col() ) right = hb_max_col();

      /* Force the box to be drawn from top left to bottom right */
      if( top > bottom )
      {
         int temp;
         temp = top;
         top = bottom;
         bottom = temp;
      }
      if( left > right )
      {
         int temp;
         temp = right;
         right = left;
         left = temp;
      }
      width = right - left + 1;
      height = bottom - top + 1;

      /* Determine the box style */
      if( ISCHAR( 5 ) )
      {
         szBorderStyle = hb_parc( 5 );
         size = hb_parclen( 5 );
      }
      else if( ISNUM( 5 ) )
      {
         switch( hb_parni( 5 ) )
         {
            case 2:
               szBorderStyle = B_DOUBLE;
               break;
            case 3:
               szBorderStyle = B_SINGLE_DOUBLE;
               break;
            case 4:
               szBorderStyle = B_DOUBLE_SINGLE;
               break;
            default:
               szBorderStyle = B_SINGLE;
         }
          size = strlen( szBorderStyle );
      }
      /* We only need 9 characters from the source string */
      if( size > 9 ) size = 9;
      /* If we have at least one character... */
      if( size )
         /* ...copy the source string */
         memcpy( Borders, szBorderStyle, size );
      else
         /* If not, set the first character to a space */
         Borders[ size++ ] = ' ';
      /* If there were less than 8 characters in the source... */
      for( ; size < 8; size++ )
      {
         /* ...copy the last character into the remaining 8 border positions */
         Borders[ size ] = Borders[ size - 1 ];
      }
      /* If there were less than 9 characters in the source... */
      if( size < 9 )
         /* ...set the fill character to space */
         Borders[ 8 ] = ' ';

      /* Draw the box */
      hb_setpos( top, left );
      if( height > 1 && width > 1 )
         printf( "%c", Borders[ 0 ] );    /* Upper left corner */
      for( col = ( height > 1 ? left + 1 : left ); col < ( height > 1 ? right : right + 1 ); col++ )
         printf( "%c", Borders[ 1 ] );    /* Top line */
      if( height > 1 && width > 1 )
         printf( "%c", Borders[ 2 ] );    /* Upper right corner */
      for( row = ( height > 1 ? top + 1 : top ); row < ( width > 1 ? bottom : bottom + 1 ); row++ )
      {
         hb_setpos( row, left );
         if( height > 1 )
            printf( "%c", Borders[ 3 ] ); /* Left side */
         if( height > 1 && width > 1 ) for( col = left + 1; col < right; col++ )
            printf( "%c", Borders[ 8 ] ); /* Fill */
         if( height > 1 && width > 1 )
            printf( "%c", Borders[ 7 ] ); /* Right side */
      }
      if( height > 1 && width > 1 )
      {
         hb_setpos( bottom, left );
         col = left;
         printf( "%c", Borders[ 6 ] );    /* Bottom left corner */
         for( col = left + 1; col < right; col++ )
            printf( "%c", Borders[ 5 ] ); /* Bottom line */
         printf( "%c", Borders[ 4 ] );    /* Bottom right corner */
      }
      hb_setpos( bottom + 1, right + 1 );
   }
#endif
}

HARBOUR HB_DISPBEGIN( void )
{
#ifdef HARBOUR_USE_GTAPI
   hb_gtDispBegin();
#endif
}

HARBOUR HB_DISPEND( void )
{
#ifdef HARBOUR_USE_GTAPI
   hb_gtDispEnd();
#endif
}

HARBOUR HB_DISPCOUNT( void )
{
#ifdef HARBOUR_USE_GTAPI
   hb_retni( hb_gtDispCount() );
#else
   hb_retni( 0 );
#endif
}

HARBOUR HB_ISCOLOR( void )
{
#ifdef HARBOUR_USE_GTAPI
   hb_retl( hb_gtIsColor() );
#else
   hb_retl( FALSE );
#endif
}

HARBOUR HB_NOSNOW( void )
{
#ifdef HARBOUR_USE_GTAPI
   if( ISLOG( 1 ) )
      hb_gtSetSnowFlag( hb_parl( 1 ) );
#endif
}

HARBOUR HB___SHADOW( void )
{
#ifdef HARBOUR_USE_GTAPI
   USHORT uiAttr;

   if( hb_pcount() == 4 )
      uiAttr = 7;
   else if( hb_pcount() == 5 )
      uiAttr = hb_parni( 5 );

   if( hb_pcount() > 3 )
      hb_gt_DrawShadow( hb_parni( 1 ) + 1,
                        hb_parni( 2 ) + 1,
                        hb_parni( 3 ) + 1,
                        hb_parni( 4 ) + 1, uiAttr );
#endif
}

HARBOUR HB_DBGSHADOW( void )
{
   HB___SHADOW();
}

HARBOUR HB_SAVESCREEN( void )
{
#ifdef HARBOUR_USE_GTAPI
   USHORT uiX;
   USHORT uiCoords[ 4 ];
   char * pBuffer;

   uiCoords[ 0 ] = 0;
   uiCoords[ 1 ] = 0;
   uiCoords[ 2 ] = hb_gtMaxRow();
   uiCoords[ 3 ] = hb_gtMaxCol();

   for( uiX = 1; uiX <= 4; uiX++ )
      if( ISNUM( uiX ) )
         uiCoords[ uiX - 1 ] = hb_parni( uiX );

   hb_gtRectSize( uiCoords[ 0 ], uiCoords[ 1 ], uiCoords[ 2 ], uiCoords[ 3 ], &uiX );
   pBuffer = ( char * ) hb_xgrab( uiX );
   hb_gtSave( uiCoords[ 0 ], uiCoords[ 1 ], uiCoords[ 2 ], uiCoords[ 3 ], pBuffer );
   hb_retclen( pBuffer, uiX );
   hb_xfree( ( void * ) pBuffer );
#else
   hb_retc( "" );
#endif
}

HARBOUR HB_RESTSCREEN( void )
{
#ifdef HARBOUR_USE_GTAPI
   if( hb_pcount() == 5 )
   {
      USHORT uiX;
      USHORT uiCoords[ 4 ];

      uiCoords[ 0 ] = 0;
      uiCoords[ 1 ] = 0;
      uiCoords[ 2 ] = hb_gtMaxRow();
      uiCoords[ 3 ] = hb_gtMaxCol();

      for( uiX = 1; uiX < 5; uiX++ )
         if( ISNUM( uiX ) )
            uiCoords[ uiX - 1 ] = hb_parni( uiX );

      hb_gtRest( uiCoords[ 0 ], uiCoords[ 1 ], uiCoords[ 2 ], uiCoords[ 3 ],
                 hb_parc( 5 ) );
   }
#endif
}

HARBOUR HB_SETCURSOR( void )
{
#ifdef HARBOUR_USE_GTAPI
   USHORT usPreviousCursor;

   hb_gtGetCursor( &usPreviousCursor );
   if( hb_pcount() == 1 )
      hb_gtSetCursor( hb_parni( 1 ) );

   hb_retni( usPreviousCursor );
#else
   hb_retni( SC_NORMAL );
#endif
}

HARBOUR HB_SETBLINK( void )
{
#ifdef HARBOUR_USE_GTAPI
   BOOL bPreviousBlink;

   hb_gtGetBlink( &bPreviousBlink );
   if( ISLOG( 1 ) )
      hb_gtSetBlink( hb_parl( 1 ) );

   hb_retl( bPreviousBlink );
#else
   hb_retl( FALSE );
#endif
}

HARBOUR HB_SETMODE( void )
{
#ifdef HARBOUR_USE_GTAPI
   if( ISNUM( 1 ) && ISNUM( 2 ) )
      hb_gtSetMode( hb_parni( 1 ), hb_parni( 2 ) );
#endif
}

HARBOUR HB___ACCEPT( void ) /* Internal Clipper function used in ACCEPT command  */
                            /* Basically the simplest Clipper function to        */
                            /* receive data. Parameter : cPrompt. Returns : cRet */
{
   char * szResult = ( char * ) hb_xgrab( ACCEPT_BUFFER_LEN ); /* Return parameter. */
   char * szPrompt = hb_parc( 1 );    /* Pass prompt                          */
   ULONG len       = hb_parclen( 1 );
   int input;

   if( hb_pcount() == 1 )          /* cPrompt passed                         */
   {
      hb_altout( s_szCrLf, CRLF_BUFFER_LEN - 1 );
      hb_altout( szPrompt, len );
   }
#if defined (OS_UNIX_COMPATIBLE) || defined(__CYGWIN__)
   /* Read the data using fgets(), because hb_inkeyPoll() doesn't support
       Unix compatible operating systems yet. */
   {
      /* Set up for echoed canonical input */
      struct termios ta;
      tcgetattr( STDIN_FILENO, &ta );
      ta.c_lflag |= ( ICANON | ECHO );
      tcsetattr( STDIN_FILENO, TCSAFLUSH, &ta );

      /* Avoid an undefined variable warning */
      input = 0;

      /* Get a line of user input */
      szResult[ 0 ] = '\0';          /* start with something defined */
      if( fgets( szResult, ACCEPT_BUFFER_LEN, stdin ) )
         strtok( szResult, "\n" ); /* strip off the trailing newline if it exists */

      /* Restore unechoed non-canonical input */
      ta.c_lflag &= ~( ICANON | ECHO );
      tcsetattr( STDIN_FILENO, TCSAFLUSH, &ta );
   }
#else
   len = 0;
   input = 0;
   while( input != 13 )
   {
      /* Wait forever, for keyboard events only */
      input = hb_inkey ( 0.0, INKEY_KEYBOARD, 1, 1 );
      switch( input )
      {
         case 8:  /* Backspace */
         case 19: /* Left arrow */
            if( len > 0 )
            {
               len--; /* Adjust input count to get rid of last character,
                         then erase it from the screen. */
#ifdef HARBOUR_USE_GTAPI
               hb_gtWriteCon( "\x8 \x8", 3L );
#else
               printf( "\x8 \x8" );
#endif
            }
            break;
         case 13:  /* Nothing to do. While loop will now exit. */
            break;
         default:
            if( len < 255 && input >= 32 && input <= 127 )
            {
               szResult[ len ] = input; /* Accept the input */
               hb_dispout( &szResult[ len ], 1 ); /* Then display it */
               len++;  /* Then adjust the input count */
            }
      }
   }
#endif
   hb_retclen( szResult, len );
   hb_xfree( szResult );
}

/* ------------------------------------------------- */
/* Copyright (C) 1999 Victor Szel <info@szelvesz.hu> */
/* ------------------------------------------------- */

/*  $DOC$
 *  $FUNCNAME$
 *      __ColorIndex
 *  $CATEGORY$
 *      GT
 *  $ONELINER$
 *      Extract one color from a full Clipper colorspec string.
 *  $SYNTAX$
 *      __ColorIndex( <cColorSpec>, <nIndex> )
 *  $ARGUMENTS$
 *      <cColorSpec> is a Clipper color list
 *      <nIndex> is the position of the color item to be extracted, the first
 *               position is the zero.
 *  $RETURNS$
 *      The selected color string, or if anything goes wrong, and empty
 *      string
 *  $DESCRIPTION$
 *      Clipper has color spec string, which have more than one single
 *      colors in it, separated with commas. This function is able to extract
 *      a given item from this list. You may use the manifest constants
 *      defined in color.ch to extract common Clipper colors.
 *  $EXAMPLES$
 *      ? __ColorIndex( "W/N, N/W", CLR_ENHANCED ) // "N/W"
 *  $TESTS$
 *      see in rtl_test.prg for a comprehensive regression test suit.
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      Was not part of CA-Clipper.
 *  $SEEALSO$
 *      ColorSelect()
 *  $END$
 */

HARBOUR HB___COLORINDEX( void )
{
   if( ISCHAR( 1 ) && ISNUM( 2 ) )
   {
      char * szColor = hb_parc( 1 );
      ULONG  ulColorPos;
      ULONG  ulColorLen;
      USHORT uiColorIndex = ( USHORT ) hb_parni( 2 );

      /* Skip the given number of commas */

      for( ulColorPos = 0 ; szColor[ ulColorPos ] != '\0' && uiColorIndex > 0 ; ulColorPos++ )
      {
         if( szColor[ ulColorPos ] == ',' )
            uiColorIndex--;
      }

      /* if found, continue */

      if( uiColorIndex == 0 )
      {
         /* Skip the spaces after the comma */

         while( szColor[ ulColorPos ] == ' ' ) ulColorPos++;

         /* Search for next comma or end of string */

         ulColorLen = 0;

         while( szColor[ ulColorPos + ulColorLen ] != '\0' &&
                szColor[ ulColorPos + ulColorLen ] != ',' ) ulColorLen++;

         /* Skip the trailing spaces */

         while( ulColorLen > 0 &&
                szColor[ ulColorPos + ulColorLen - 1 ] == ' ' ) ulColorLen--;

         /* Return the string */

         hb_retclen( szColor + ulColorPos, ulColorLen );
      }
      else
         hb_retc( "" );
   }
   else
      hb_retc( "" );
}