fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2007-12-17 21:21 UTC+0100 Przemyslaw Czerpak (druzus/at/priv.onet.pl)

Browse Source 
* harbour/include/hbapigt.h
  * harbour/include/hbgtcore.h
  * harbour/source/rtl/gtapi.c
  * harbour/source/rtl/hbgtcore.c
  * harbour/source/rtl/gt_tpl/gt_tpl.c
  * harbour/source/rtl/gtdos/gtdos.c
  * harbour/source/rtl/gtwin/gtwin.c
  * harbour/source/rtl/gtxwc/gtxwc.c
  * harbour/source/rtl/gtos2/gtos2.c
  * harbour/source/rtl/gtcrs/gtcrs.c
  * harbour/source/rtl/gtsln/gtsln.c
  * harbour/source/rtl/gttrm/gttrm.c
  * harbour/source/rtl/gtpca/gtpca.c
  * harbour/source/rtl/gtgui/gtgui.c
  * harbour/source/rtl/gtwvt/gtwvt.c
  * harbour/source/rtl/gtcgi/gtcgi.c
  * harbour/source/rtl/gtstd/gtstd.c
  * harbour/contrib/hbct/ctwin.c
  * harbour/contrib/hbgtwvg/gtwvg.c
  * harbour/source/rtl/gtalleg/gtalleg.c
  * harbour/source/rtl/gtalleg/ssf.h
  * harbour/source/rtl/gtalleg/fixedth.sfc
    * added missing const to few declarations
    * formatting and minor code cleanup

  * harbour/source/rtl/hbgtcore.c
    ! fixed GTNUL registration

  * harbour/source/rtl/gtcgi/gtcgi.c
  * harbour/source/rtl/gtstd/gtstd.c
    * moved static variables to dynamic GT area

  * harbour/contrib/hbct/files.c
    ! fixed DOS version
This commit is contained in:
Przemyslaw Czerpak
2007-12-17 20:22:32 +00:00
parent 392a5fb27a
commit cb47250bfc
24 changed files with 1862 additions and 1752 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
harbour/ChangeLog
View File

@@ -8,6 +8,42 @@
2002-12-01 13:30 UTC+0100 Foo Bar <foo.bar@foobar.org>
*/
2007-12-17 21:21 UTC+0100 Przemyslaw Czerpak (druzus/at/priv.onet.pl)
* harbour/include/hbapigt.h
* harbour/include/hbgtcore.h
* harbour/source/rtl/gtapi.c
* harbour/source/rtl/hbgtcore.c
* harbour/source/rtl/gt_tpl/gt_tpl.c
* harbour/source/rtl/gtdos/gtdos.c
* harbour/source/rtl/gtwin/gtwin.c
* harbour/source/rtl/gtxwc/gtxwc.c
* harbour/source/rtl/gtos2/gtos2.c
* harbour/source/rtl/gtcrs/gtcrs.c
* harbour/source/rtl/gtsln/gtsln.c
* harbour/source/rtl/gttrm/gttrm.c
* harbour/source/rtl/gtpca/gtpca.c
* harbour/source/rtl/gtgui/gtgui.c
* harbour/source/rtl/gtwvt/gtwvt.c
* harbour/source/rtl/gtcgi/gtcgi.c
* harbour/source/rtl/gtstd/gtstd.c
* harbour/contrib/hbct/ctwin.c
* harbour/contrib/hbgtwvg/gtwvg.c
* harbour/source/rtl/gtalleg/gtalleg.c
* harbour/source/rtl/gtalleg/ssf.h
* harbour/source/rtl/gtalleg/fixedth.sfc
* added missing const to few declarations
* formatting and minor code cleanup
* harbour/source/rtl/hbgtcore.c
! fixed GTNUL registration
* harbour/source/rtl/gtcgi/gtcgi.c
* harbour/source/rtl/gtstd/gtstd.c
* moved static variables to dynamic GT area
* harbour/contrib/hbct/files.c
! fixed DOS version
2007-12-17 13:41 UTC+0100 Miguel Angel Marchuet Frutos <miguelangel@marchuet.net>
* common.mak
+ Added some missing files (suggested by Juan Gálvez)

10
harbour/contrib/hbct/ctwin.c
View File

@@ -1858,12 +1858,12 @@ static BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable )
/* ********************************************************************** */
static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
static const HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
HB_GT_ANNOUNCE( HB_GT_NAME );
HB_GT_ANNOUNCE( HB_GT_NAME )
HB_CALL_ON_STARTUP_BEGIN( _hb_startup_gt_Init_ )
hb_gtRegister( &gtInit );

2
harbour/contrib/hbct/files.c
View File

@@ -198,7 +198,7 @@ HB_FUNC( SETFATTR )
#if defined( __DJGPP__ ) || defined( __BORLANDC__ )
iReturn = _chmod( szFile, 1, iFlags );
#else
iReturn = _dos_setfileattr( pszDirName, iFlags );
iReturn = _dos_setfileattr( szFile, iFlags );
#endif
}
hb_retni( iReturn );

8
harbour/contrib/hbgtwvg/gtwvg.c
View File

@@ -2768,10 +2768,10 @@ static BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable )
/* ********************************************************************** */
static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
static const HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
HB_GT_ANNOUNCE( HB_GT_NAME )

16
harbour/include/hbapigt.h
View File

@@ -222,10 +222,24 @@ extern HB_EXPORT BOOL hb_mouseButtonPressed( int iButton, int * piRow, int *
extern HB_EXPORT BOOL hb_mouseButtonReleased( int iButton, int * piRow, int * piCol );
extern HB_EXPORT int hb_mouseReadKey( int iEventMask );
typedef struct
{
int iTop;
int iLeft;
int iBottom;
int iRight;
} HB_GT_RECT;
typedef HB_GT_RECT * PHB_GT_RECT;
typedef struct
{
int iRow;
int iCol;
} HB_GT_CORD;
typedef HB_GT_CORD * PHB_GT_CORD;
/* Undocumented CA-Clipper 5.x GT API calls */
#define HB_GT_RECT void
#define HB_GT_WND void
#define HB_GT_RGB void
#define HB_GT_SLR void

19
harbour/include/hbgtcore.h
View File

@@ -286,23 +286,6 @@ typedef union
} HB_SCREENCELL;
typedef HB_SCREENCELL * PHB_SCREENCELL;
/*
typedef struct
{
int iTop;
int iLeft;
int iBottom;
int iRight;
} HB_GT_RECT;
typedef HB_GT_RECT * PHB_GT_RECT;
typedef struct
{
int iRow;
int iCol;
} HB_GT_CORD;
typedef HB_GT_CORD * PHB_GT_CORD;
*/
typedef struct _HB_GT_BASE
{
@@ -599,7 +582,7 @@ extern PHB_GT hb_gt_Base( void );
#define HB_GTSUPER_WHOCARES(g,p) (HB_GTSUPER)->WhoCares(g,p)
extern HB_EXPORT void hb_gtSetDefault( const char * szGtName );
extern HB_EXPORT BOOL hb_gtRegister( PHB_GT_INIT gtInit );
extern HB_EXPORT BOOL hb_gtRegister( const HB_GT_INIT * gtInit );
extern HB_EXPORT BOOL hb_gtLoad( const char * szGtName, PHB_GT_FUNCS pFuncTable );
extern HB_EXPORT BOOL hb_gtUnLoad( void );
extern HB_EXPORT void hb_gtStartupInit( void );

8
harbour/source/rtl/gt_tpl/gt_tpl.c
View File

@@ -166,10 +166,10 @@ static BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable )
/* ********************************************************************** */
static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
static const HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
HB_GT_ANNOUNCE( HB_GT_NAME )

2518
harbour/source/rtl/gtalleg/fixedth.sfc
View File

File diff suppressed because it is too large Load Diff

335
harbour/source/rtl/gtalleg/gtalleg.c
View File

@@ -71,24 +71,46 @@ static HB_GT_FUNCS SuperTable;
#define HB_GTSUPER (&SuperTable)
#define HB_GTID_PTR (&s_GtId)
static BOOL s_fInit;
static BOOL s_fMakeInit;
static BOOL s_fGtError;
/* font definition */
static ssfFont s_ssfDefaultFont;
static BYTE s_byFontSize = 16;
static int s_byFontWidth = 8;
static int s_iMsButtons, s_iMSBoundTop, s_iMSBoundLeft, s_iMSBoundBottom, s_iMSBoundRight;
static int s_iMSX, s_iMSY;
static BYTE s_byMSButtons;
static int s_iScrWidth = 80, s_iScrHeight = 25;
static int s_iGFXWidth = 0, s_iGFXHeight = 0;
static int s_iGFXUpdTop, s_iGFXUpdLeft, s_iGFXUpdBottom, s_iGFXUpdRight;
static int s_iCTop, s_iCLeft, s_iCBottom, s_iCRight;
static int s_iCurCol, s_iCurRow;
/* mouse parameters */
static int s_iMsButtons;
static int s_mouseButtonsState;
static HB_GT_RECT s_mouseBound;
static HB_GT_CORD s_mousePos;
/* screen size in characters */
static int s_iScrWidth = 80;
static int s_iScrHeight = 25;
/* screen size in pixels */
static int s_iGFXWidth = 0;
static int s_iGFXHeight = 0;
/* update region in pixels */
static HB_GT_RECT s_GFXUpd;
/* current CLIP region in pixels (modified by GFX_SETCLIP) */
static HB_GT_RECT s_CLIP;
/* cursor position and style */
static int s_iCurCol;
static int s_iCurRow;
static int s_iCursorStyle;
/* color indexes */
static int s_pClr[16];
static BYTE s_byFontSize = 16, s_byFontWidth = 8;
static AL_BITMAP * bmp = NULL;
/* screen buffer bitmap */
static AL_BITMAP * s_bmp = NULL;
/*
* I'm not sure of removing these (yet)
@@ -100,6 +122,7 @@ static AL_BITMAP * bmp = NULL;
#define s_iHBorder 0
#define s_iVBorder 0
typedef struct {
int al_key;
int xhb_key;
@@ -107,7 +130,7 @@ typedef struct {
#define GT_KEY_TABLE_SIZE 49
static const gtAllegKey sKeyTable[GT_KEY_TABLE_SIZE] = {
static const gtAllegKey s_KeyTable[GT_KEY_TABLE_SIZE] = {
{AL_KEY_ESC, K_ESC},
{AL_KEY_INSERT, K_INS},
{AL_KEY_HOME, K_HOME},
@@ -161,7 +184,7 @@ static const gtAllegKey sKeyTable[GT_KEY_TABLE_SIZE] = {
#define GT_CTRL_TABLE_SIZE 11
static const gtAllegKey sCtrlTable[GT_CTRL_TABLE_SIZE] = {
static const gtAllegKey s_CtrlTable[GT_CTRL_TABLE_SIZE] = {
{AL_KEY_LEFT, K_CTRL_LEFT},
{AL_KEY_RIGHT, K_CTRL_RIGHT},
{AL_KEY_UP, K_CTRL_UP},
@@ -175,10 +198,10 @@ static const gtAllegKey sCtrlTable[GT_CTRL_TABLE_SIZE] = {
{AL_KEY_PGDN, K_CTRL_PGDN}
};
#define GT_UPD_GFXRECT(t,l,b,r) do { if( t < s_iGFXUpdTop ) s_iGFXUpdTop = t; \
if( l < s_iGFXUpdLeft ) s_iGFXUpdLeft = l; \
if( b > s_iGFXUpdBottom ) s_iGFXUpdBottom=b; \
if( r > s_iGFXUpdRight ) s_iGFXUpdRight=r; \
#define GT_UPD_GFXRECT(t,l,b,r) do { if( t < s_GFXUpd.iTop ) s_GFXUpd.iTop = t; \
if( l < s_GFXUpd.iLeft ) s_GFXUpd.iLeft = l; \
if( b > s_GFXUpd.iBottom ) s_GFXUpd.iBottom = b; \
if( r > s_GFXUpd.iRight ) s_GFXUpd.iRight = r; \
} while(0)
#define GT_SCREENINIT() do { if( !s_fInit ) \
hb_gt_alleg_InitializeScreen( pGT, s_iScrHeight, s_iScrWidth, TRUE ); \
@@ -239,7 +262,7 @@ static void hb_gt_alleg_DoCursor( int iRow, int iCol, int iStyle )
&iTop, &iLeft, &iBottom, &iRight ) )
{
al_scare_mouse_area( iLeft, iTop, iRight, iBottom );
al_blit( bmp, al_screen, iLeft, iTop, iLeft, iTop, iRight - iLeft + 1, iBottom - iTop + 1 );
al_blit( s_bmp, al_screen, iLeft, iTop, iLeft, iTop, iRight - iLeft + 1, iBottom - iTop + 1 );
al_unscare_mouse();
}
/* Show the new one */
@@ -266,7 +289,8 @@ static void hb_gt_alleg_ScreenUpdate( PHB_GT pGT )
HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_ScreenUpdate(%p)", pGT));
HB_GTSELF_GETSCRCURSOR( pGT, &iRow, &iCol, &iStyle );
fPix = s_iGFXUpdTop <= s_iGFXUpdBottom && s_iGFXUpdLeft <= s_iGFXUpdRight;
fPix = s_GFXUpd.iTop <= s_GFXUpd.iBottom &&
s_GFXUpd.iLeft <= s_GFXUpd.iRight;
fCursor = s_iCurRow != iRow || s_iCurCol != iCol || s_iCursorStyle != iStyle;
if( fPix || fCursor )
@@ -275,8 +299,12 @@ static void hb_gt_alleg_ScreenUpdate( PHB_GT pGT )
if( fPix )
{
al_scare_mouse_area( s_iGFXUpdLeft, s_iGFXUpdTop, s_iGFXUpdRight, s_iGFXUpdBottom );
al_blit( bmp, al_screen, s_iGFXUpdLeft, s_iGFXUpdTop, s_iGFXUpdLeft, s_iGFXUpdTop, s_iGFXUpdRight - s_iGFXUpdLeft + 1, s_iGFXUpdBottom - s_iGFXUpdTop + 1 );
al_scare_mouse_area( s_GFXUpd.iLeft, s_GFXUpd.iTop,
s_GFXUpd.iRight, s_GFXUpd.iBottom );
al_blit( s_bmp, al_screen, s_GFXUpd.iLeft, s_GFXUpd.iTop,
s_GFXUpd.iLeft, s_GFXUpd.iTop,
s_GFXUpd.iRight - s_GFXUpd.iLeft + 1,
s_GFXUpd.iBottom - s_GFXUpd.iTop + 1 );
al_unscare_mouse();
}
if( fCursor )
@@ -285,10 +313,10 @@ static void hb_gt_alleg_ScreenUpdate( PHB_GT pGT )
}
al_release_screen();
s_iGFXUpdTop = s_iScrHeight * s_byFontSize;
s_iGFXUpdLeft = s_iScrWidth * s_byFontWidth;
s_iGFXUpdBottom = 0;
s_iGFXUpdRight = 0;
s_GFXUpd.iTop = s_iScrHeight * s_byFontSize;
s_GFXUpd.iLeft = s_iScrWidth * s_byFontWidth;
s_GFXUpd.iBottom = 0;
s_GFXUpd.iRight = 0;
}
}
@@ -308,8 +336,8 @@ static BOOL hb_gt_alleg_InitializeScreen( PHB_GT pGT, int iRows, int iCols, BOOL
if( lPrev )
{
al_destroy_bitmap(bmp);
bmp = NULL;
al_destroy_bitmap(s_bmp);
s_bmp = NULL;
}
if( s_iGFXWidth != 0 && s_iGFXHeight != 0 )
@@ -414,11 +442,11 @@ static BOOL hb_gt_alleg_InitializeScreen( PHB_GT pGT, int iRows, int iCols, BOOL
}
s_fInit = TRUE;
s_iMSBoundLeft = 0;
s_iMSBoundTop = 0;
s_iMSBoundRight = AL_SCREEN_W - 1;
s_iMSBoundBottom = AL_SCREEN_H - 1;
s_byMSButtons = (BYTE) al_mouse_b;
s_mouseBound.iLeft = 0;
s_mouseBound.iTop = 0;
s_mouseBound.iRight = AL_SCREEN_W - 1;
s_mouseBound.iBottom = AL_SCREEN_H - 1;
s_mouseButtonsState = al_mouse_b;
al_show_mouse(al_screen);
s_iScrWidth = iCols;
s_iScrHeight = iRows;
@@ -456,16 +484,16 @@ static BOOL hb_gt_alleg_InitializeScreen( PHB_GT pGT, int iRows, int iCols, BOOL
s_byFontWidth = s_byFontSize / 2;
}
s_iMSX = al_mouse_x / s_byFontWidth;
s_iMSY = al_mouse_y / s_byFontSize;
s_iGFXUpdTop = s_iScrHeight;
s_iGFXUpdLeft = s_iScrWidth;
s_iGFXUpdBottom = 0;
s_iGFXUpdRight = 0;
s_iCTop = 0;
s_iCLeft = 0;
s_iCBottom = AL_SCREEN_H - 1;
s_iCRight = AL_SCREEN_W - 1;
s_mousePos.iCol = al_mouse_x / s_byFontWidth;
s_mousePos.iRow = al_mouse_y / s_byFontSize;
s_GFXUpd.iTop = s_iScrHeight;
s_GFXUpd.iLeft = s_iScrWidth;
s_GFXUpd.iBottom = 0;
s_GFXUpd.iRight = 0;
s_CLIP.iTop = 0;
s_CLIP.iLeft = 0;
s_CLIP.iBottom = AL_SCREEN_H - 1;
s_CLIP.iRight = AL_SCREEN_W - 1;
s_iCurCol = 0;
s_iCurRow = 0;
s_iCursorStyle = SC_NONE;
@@ -487,11 +515,11 @@ static BOOL hb_gt_alleg_InitializeScreen( PHB_GT pGT, int iRows, int iCols, BOOL
s_pClr[14] = al_make_color(0xFF, 0xFF, 0x55); /* yellow */
s_pClr[15] = al_make_color(0xFF, 0xFF, 0xFF); /* bright white */
bmp = al_create_system_bitmap(AL_SCREEN_W, AL_SCREEN_H);
if( bmp == NULL )
s_bmp = al_create_system_bitmap(AL_SCREEN_W, AL_SCREEN_H);
if( s_bmp == NULL )
{
bmp = al_create_bitmap(AL_SCREEN_W, AL_SCREEN_H);
if( bmp == NULL )
s_bmp = al_create_bitmap(AL_SCREEN_W, AL_SCREEN_H);
if( s_bmp == NULL )
{
hb_gt_alleg_Error( "Could not allocate double buffer bitmap" );
}
@@ -500,7 +528,7 @@ static BOOL hb_gt_alleg_InitializeScreen( PHB_GT pGT, int iRows, int iCols, BOOL
if( !lClearInit )
{
BYTE bColor = s_pClr[ ( HB_GTSELF_GETCLEARCOLOR( pGT ) >> 4 ) & 0x0f ];
al_clear_to_color( bmp, bColor );
al_clear_to_color( s_bmp, bColor );
al_clear_to_color( al_screen, bColor );
}
@@ -548,10 +576,10 @@ static void hb_gt_alleg_Exit( PHB_GT pGT )
HB_GTSUPER_EXIT( pGT );
if( bmp )
if( s_bmp )
{
al_destroy_bitmap( bmp );
bmp = NULL;
al_destroy_bitmap( s_bmp );
s_bmp = NULL;
}
}
@@ -577,10 +605,12 @@ static BOOL hb_gt_alleg_SetMode( PHB_GT pGT, int iRows, int iCols )
static int hb_gt_alleg_ReadKey( PHB_GT pGT, int iEventMask )
{
int nKey = 0;
int i, iMSX, iMSY;
int i, iMseCol, iMseRow;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_ReadKey(%p,%d)", pGT, iEventMask));
HB_SYMBOL_UNUSED( iEventMask );
GT_SCREENINIT();
if( al_mouse_needs_poll() )
@@ -588,73 +618,43 @@ static int hb_gt_alleg_ReadKey( PHB_GT pGT, int iEventMask )
al_poll_mouse();
}
iMSX = al_mouse_x / s_byFontWidth;
iMSY = al_mouse_y / s_byFontSize;
if( iMSX != s_iMSX || iMSY != s_iMSY )
iMseCol = al_mouse_x / s_byFontWidth;
iMseRow = al_mouse_y / s_byFontSize;
if( iMseCol != s_mousePos.iCol || iMseRow != s_mousePos.iRow )
{
s_iMSX = iMSX;
s_iMSY = iMSY;
if( iEventMask & INKEY_MOVE )
{
nKey = K_MOUSEMOVE;
}
s_mousePos.iCol = iMseCol;
s_mousePos.iRow = iMseRow;
nKey = K_MOUSEMOVE;
}
if( nKey == 0 && ( BYTE ) al_mouse_b != s_byMSButtons )
if( nKey == 0 && al_mouse_b != s_mouseButtonsState )
{
if( ( al_mouse_b & 1 ) != ( s_byMSButtons & 1 ) )
if( ( al_mouse_b & 1 ) != ( s_mouseButtonsState & 1 ) )
{
if( al_mouse_b & 1 )
{
if( iEventMask & INKEY_LDOWN )
{
nKey = K_LBUTTONDOWN;
}
}
nKey = K_LBUTTONDOWN;
else
{
if( iEventMask & INKEY_LUP )
{
nKey = K_LBUTTONUP;
}
}
} else if( ( al_mouse_b & 2 ) != ( s_byMSButtons & 2 ) )
nKey = K_LBUTTONUP;
}
else if( ( al_mouse_b & 2 ) != ( s_mouseButtonsState & 2 ) )
{
if( al_mouse_b & 2 )
{
if( iEventMask & INKEY_RDOWN )
{
nKey = K_RBUTTONDOWN;
}
}
nKey = K_RBUTTONDOWN;
else
{
if( iEventMask & INKEY_RUP )
{
nKey = K_RBUTTONUP;
}
}
} /* else if( ( al_mouse_b & 4 ) != ( s_byMSButtons & 4 ) )
nKey = K_RBUTTONUP;
}
else if( ( al_mouse_b & 4 ) != ( s_mouseButtonsState & 4 ) )
{
if( al_mouse_b & 4 )
{
if( iEventMask & INKEY_MDOWN )
{
nKey = K_MBUTTONDOWN;
}
} else
{
if( iEventMask & INKEY_MUP )
{
nKey = K_MBUTTONUP;
}
}
} */
nKey = K_MBUTTONDOWN;
else
nKey = K_MBUTTONUP;
}
/* We need to define INKEY_M* & K_MBUTTON* in inkey.ch ! */
s_byMSButtons = (BYTE) al_mouse_b;
s_mouseButtonsState = al_mouse_b;
}
if( nKey == 0 && ( iEventMask & INKEY_KEYBOARD ) )
if( nKey == 0 )
{
if( al_keyboard_needs_poll() )
{
@@ -678,9 +678,9 @@ static int hb_gt_alleg_ReadKey( PHB_GT pGT, int iEventMask )
{
for( i = 0; i < GT_CTRL_TABLE_SIZE; i++ )
{
if( ( nKey >> 8 ) == sCtrlTable[i].al_key )
if( ( nKey >> 8 ) == s_CtrlTable[i].al_key )
{
nKey = sCtrlTable[i].xhb_key;
nKey = s_CtrlTable[i].xhb_key;
break;
}
}
@@ -716,9 +716,9 @@ static int hb_gt_alleg_ReadKey( PHB_GT pGT, int iEventMask )
{
for( i = 0; i < GT_KEY_TABLE_SIZE; i++ )
{
if( ( nKey >> 8 ) == sKeyTable[i].al_key )
if( ( nKey >> 8 ) == s_KeyTable[i].al_key )
{
nKey = sKeyTable[i].xhb_key;
nKey = s_KeyTable[i].xhb_key;
break;
}
}
@@ -780,35 +780,36 @@ static void hb_gt_alleg_mouse_SetBounds( PHB_GT pGT, int iTop, int iLeft, int iB
if( iTop > -1 && iTop * s_byFontSize < AL_SCREEN_H )
{
s_iMSBoundTop = iTop * s_byFontSize;
s_mouseBound.iTop = iTop * s_byFontSize;
}
if( iLeft > -1 && iLeft * s_byFontWidth < AL_SCREEN_W )
{
s_iMSBoundLeft = iLeft * s_byFontWidth;
s_mouseBound.iLeft = iLeft * s_byFontWidth;
}
if( iBottom >= iTop && iBottom * s_byFontSize < AL_SCREEN_H )
{
s_iMSBoundBottom = iBottom * s_byFontSize;
s_mouseBound.iBottom = iBottom * s_byFontSize;
}
if( iRight >= iLeft && iRight * s_byFontWidth < AL_SCREEN_W )
{
s_iMSBoundRight = iRight * s_byFontWidth;
s_mouseBound.iRight = iRight * s_byFontWidth;
}
al_set_mouse_range( s_iMSBoundLeft, s_iMSBoundTop, s_iMSBoundRight, s_iMSBoundBottom );
al_set_mouse_range( s_mouseBound.iLeft, s_mouseBound.iTop,
s_mouseBound.iRight, s_mouseBound.iBottom );
}
static void hb_gt_alleg_mouse_GetBounds( PHB_GT pGT, int *piTop, int *piLeft, int *piBottom, int *piRight )
{
GT_SCREENINIT();
*piTop = s_iMSBoundTop;
*piLeft = s_iMSBoundLeft;
*piBottom = s_iMSBoundBottom;
*piRight = s_iMSBoundRight;
*piTop = s_mouseBound.iTop;
*piLeft = s_mouseBound.iLeft;
*piBottom = s_mouseBound.iBottom;
*piRight = s_mouseBound.iRight;
}
static BOOL hb_gt_alleg_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo )
@@ -940,11 +941,11 @@ static int hb_gt_alleg_gfx_Primitive( PHB_GT pGT, int iType, int iTop, int iLeft
switch( iType )
{
case GFX_ACQUIRESCREEN:
al_acquire_bitmap(bmp);
al_acquire_bitmap(s_bmp);
break;
case GFX_RELEASESCREEN:
al_release_bitmap(bmp);
al_release_bitmap(s_bmp);
break;
case GFX_MAKECOLOR:
@@ -952,27 +953,27 @@ static int hb_gt_alleg_gfx_Primitive( PHB_GT pGT, int iType, int iTop, int iLeft
break;
case GFX_CLIPTOP:
iRet = s_iCTop;
iRet = s_CLIP.iTop;
break;
case GFX_CLIPLEFT:
iRet = s_iCLeft;
iRet = s_CLIP.iLeft;
break;
case GFX_CLIPBOTTOM:
iRet = s_iCBottom;
iRet = s_CLIP.iBottom;
break;
case GFX_CLIPRIGHT:
iRet = s_iCRight;
iRet = s_CLIP.iRight;
break;
case GFX_SETCLIP:
al_set_clip(bmp, iLeft, iTop, iRight, iBottom);
s_iCTop = iTop;
s_iCLeft = iLeft;
s_iCBottom = iBottom;
s_iCRight = iRight;
al_set_clip(s_bmp, iLeft, iTop, iRight, iBottom);
s_CLIP.iTop = iTop;
s_CLIP.iLeft = iLeft;
s_CLIP.iBottom = iBottom;
s_CLIP.iRight = iRight;
break;
case GFX_DRAWINGMODE:
@@ -980,74 +981,74 @@ static int hb_gt_alleg_gfx_Primitive( PHB_GT pGT, int iType, int iTop, int iLeft
break;
case GFX_GETPIXEL:
iRet = al_get_pixel(bmp, iLeft, iTop);
iRet = al_get_pixel(s_bmp, iLeft, iTop);
break;
case GFX_PUTPIXEL:
al_acquire_bitmap(bmp);
al_put_pixel(bmp, iLeft, iTop, iBottom);
al_release_bitmap(bmp);
al_acquire_bitmap(s_bmp);
al_put_pixel(s_bmp, iLeft, iTop, iBottom);
al_release_bitmap(s_bmp);
GT_UPD_GFXRECT(iTop,iLeft,iTop,iLeft);
break;
case GFX_LINE:
al_acquire_bitmap(bmp);
al_acquire_bitmap(s_bmp);
if( iLeft == iRight )
al_draw_vline(bmp, iLeft, iTop, iBottom, iColor);
al_draw_vline(s_bmp, iLeft, iTop, iBottom, iColor);
else if( iTop == iBottom )
al_draw_hline(bmp, iLeft, iTop, iRight, iColor);
al_draw_hline(s_bmp, iLeft, iTop, iRight, iColor);
else
al_draw_line(bmp, iLeft, iTop, iRight, iBottom, iColor);
al_release_bitmap(bmp);
al_draw_line(s_bmp, iLeft, iTop, iRight, iBottom, iColor);
al_release_bitmap(s_bmp);
GT_UPD_GFXRECT(iTop,iLeft,iBottom,iRight);
break;
case GFX_RECT:
al_acquire_bitmap(bmp);
al_draw_rect(bmp, iLeft, iTop, iRight, iBottom, iColor);
al_release_bitmap(bmp);
al_acquire_bitmap(s_bmp);
al_draw_rect(s_bmp, iLeft, iTop, iRight, iBottom, iColor);
al_release_bitmap(s_bmp);
GT_UPD_GFXRECT(iTop,iLeft,iBottom,iRight);
break;
case GFX_FILLEDRECT:
al_acquire_bitmap(bmp);
al_draw_rect_fill(bmp, iLeft, iTop, iRight, iBottom, iColor);
al_release_bitmap(bmp);
al_acquire_bitmap(s_bmp);
al_draw_rect_fill(s_bmp, iLeft, iTop, iRight, iBottom, iColor);
al_release_bitmap(s_bmp);
GT_UPD_GFXRECT(iTop,iLeft,iBottom,iRight);
break;
case GFX_CIRCLE:
al_acquire_bitmap(bmp);
al_draw_circle(bmp, iLeft, iTop, iBottom, iRight);
al_release_bitmap(bmp);
al_acquire_bitmap(s_bmp);
al_draw_circle(s_bmp, iLeft, iTop, iBottom, iRight);
al_release_bitmap(s_bmp);
GT_UPD_GFXRECT(iTop-iBottom,iLeft-iBottom,iTop+iBottom,iLeft+iBottom);
break;
case GFX_FILLEDCIRCLE:
al_acquire_bitmap(bmp);
al_draw_circle_fill(bmp, iLeft, iTop, iBottom, iRight);
al_release_bitmap(bmp);
al_acquire_bitmap(s_bmp);
al_draw_circle_fill(s_bmp, iLeft, iTop, iBottom, iRight);
al_release_bitmap(s_bmp);
GT_UPD_GFXRECT(iTop-iBottom,iLeft-iBottom,iTop+iBottom,iLeft+iBottom);
break;
case GFX_ELLIPSE:
al_acquire_bitmap(bmp);
al_draw_ellipse(bmp, iLeft, iTop, iRight, iBottom, iColor);
al_release_bitmap(bmp);
al_acquire_bitmap(s_bmp);
al_draw_ellipse(s_bmp, iLeft, iTop, iRight, iBottom, iColor);
al_release_bitmap(s_bmp);
GT_UPD_GFXRECT(iTop-iBottom,iLeft-iRight,iTop+iBottom,iLeft+iRight);
break;
case GFX_FILLEDELLIPSE:
al_acquire_bitmap(bmp);
al_draw_ellipse_fill(bmp, iLeft, iTop, iRight, iBottom, iColor);
al_release_bitmap(bmp);
al_acquire_bitmap(s_bmp);
al_draw_ellipse_fill(s_bmp, iLeft, iTop, iRight, iBottom, iColor);
al_release_bitmap(s_bmp);
GT_UPD_GFXRECT(iTop-iBottom,iLeft-iRight,iTop+iBottom,iLeft+iRight);
break;
case GFX_FLOODFILL:
al_acquire_bitmap(bmp);
al_floodfill(bmp, iLeft, iTop, iBottom);
al_release_bitmap(bmp);
al_acquire_bitmap(s_bmp);
al_floodfill(s_bmp, iLeft, iTop, iBottom);
al_release_bitmap(s_bmp);
GT_UPD_GFXRECT(0,0,s_iScrHeight*s_byFontSize,s_iScrWidth*s_byFontWidth);
break;
@@ -1082,9 +1083,9 @@ static void hb_gt_alleg_gfx_Text( PHB_GT pGT, int iTop, int iLeft, char * cBuf,
iRight = iLeft + strlen(cBuf) * ( s_ssfDefaultFont.fsize / 2 ) - 1;
iBottom = iTop + s_ssfDefaultFont.fsize - 1;
al_acquire_bitmap(bmp);
ssfDrawText( bmp, &s_ssfDefaultFont, cBuf, iLeft, iTop, iColor );
al_release_bitmap(bmp);
al_acquire_bitmap(s_bmp);
ssfDrawText( s_bmp, &s_ssfDefaultFont, cBuf, iLeft, iTop, iColor );
al_release_bitmap(s_bmp);
GT_UPD_GFXRECT( iTop, iLeft, iBottom, iRight );
if( iSize )
@@ -1122,8 +1123,8 @@ static void hb_gt_alleg_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize )
{
if( !HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol++, &bColor, &bAttr, &usChar ) )
break;
al_draw_rect_fill( bmp, iPosX, iPosY, iPosX + s_byFontWidth - 1, iPosY + s_byFontSize - 1, s_pClr[bColor >> 4] );
ssfDrawChar( bmp, &s_ssfDefaultFont, ( BYTE ) usChar, iPosX, iPosY, s_pClr[bColor & 0x0F] );
al_draw_rect_fill( s_bmp, iPosX, iPosY, iPosX + s_byFontWidth - 1, iPosY + s_byFontSize - 1, s_pClr[bColor >> 4] );
ssfDrawChar( s_bmp, &s_ssfDefaultFont, ( BYTE ) usChar, iPosX, iPosY, s_pClr[bColor & 0x0F] );
iPosX += s_byFontWidth;
}
}
@@ -1153,9 +1154,9 @@ static void hb_gt_alleg_Refresh( PHB_GT pGT )
{
if( s_fInit )
{
al_acquire_bitmap(bmp);
al_acquire_bitmap(s_bmp);
HB_GTSUPER_REFRESH( pGT );
al_release_bitmap(bmp);
al_release_bitmap(s_bmp);
if( HB_GTSELF_DISPCOUNT( pGT ) == 0 )
{
hb_gt_alleg_ScreenUpdate( pGT );
@@ -1205,10 +1206,10 @@ static BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable )
/* ********************************************************************** */
static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
static const HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
HB_GT_ANNOUNCE( HB_GT_NAME )

2
harbour/source/rtl/gtalleg/ssf.h
View File

@@ -230,7 +230,7 @@ typedef struct _ssfGlyph {
typedef struct _ssfFont {
unsigned short fsize;
ssfGlyph **chars;
const ssfGlyph **chars;
} ssfFont;
extern void ssfCreateThinFont(ssfFont *sfont);

7
harbour/source/rtl/gtapi.c
View File

@@ -304,6 +304,7 @@ HB_EXPORT ERRCODE hb_gtGetColorStr( char * pszColorString )
HB_GTSELF_GETCOLORSTR( pGT, pszColorString );
return SUCCESS;
}
pszColorString[0] = '\0';
return FAILURE;
}
@@ -329,6 +330,7 @@ HB_EXPORT ERRCODE hb_gtColorsToString( int * pColors, int iColorCount, char * ps
HB_GTSELF_COLORSTOSTRING( pGT, pColors, iColorCount, pszColorString, iBufSize );
return SUCCESS;
}
pszColorString[0] = '\0';
return FAILURE;
}
@@ -396,6 +398,7 @@ HB_EXPORT ERRCODE hb_gtGetPos( SHORT * piRow, SHORT * piCol )
*piCol = ( SHORT ) iCol;
return SUCCESS;
}
*piRow = *piCol = 0;
return FAILURE;
}
@@ -454,6 +457,7 @@ HB_EXPORT ERRCODE hb_gtScrDim( USHORT * uipHeight, USHORT * uipWidth )
*uipWidth = ( USHORT ) iWidth;
return SUCCESS;
}
*uipHeight = *uipWidth = 0;
return FAILURE;
}
@@ -484,6 +488,7 @@ HB_EXPORT ERRCODE hb_gtRectSize( int iTop, int iLeft, int iBottom, int iRight, U
*pulBuffSize = HB_GTSELF_RECTSIZE( pGT, iTop, iLeft, iBottom, iRight );
return SUCCESS;
}
*pulBuffSize = 0;
return FAILURE;
}
@@ -611,6 +616,7 @@ HB_EXPORT ERRCODE hb_gtGetBlink( BOOL * bpBlink )
*bpBlink = HB_GTSELF_GETBLINK( pGT );
return SUCCESS;
}
*bpBlink = 0;
return FAILURE;
}
@@ -1029,6 +1035,7 @@ HB_EXPORT ERRCODE hb_gtGetPosEx( int * piRow, int * piCol )
HB_GTSELF_GETPOS( pGT, piRow, piCol );
return SUCCESS;
}
*piRow = *piCol = 0;
return FAILURE;
}

199
harbour/source/rtl/gtcgi/gtcgi.c
View File

@@ -81,47 +81,49 @@ static HB_GT_FUNCS SuperTable;
#define HB_GTSUPER (&SuperTable)
#define HB_GTID_PTR (&s_GtId)
static FHANDLE s_hFilenoStdin;
static FHANDLE s_hFilenoStdout;
static FHANDLE s_hFilenoStderr;
static int s_iRow;
static int s_iCol;
static int s_iLastCol;
static int s_iLineBufSize;
static BYTE * s_sLineBuf;
static BYTE * s_szCrLf;
static ULONG s_ulCrLf;
static BYTE s_szBell[] = { HB_CHAR_BEL, 0 };
static BOOL s_fDispTrans;
static PHB_CODEPAGE s_cdpTerm;
static PHB_CODEPAGE s_cdpHost;
#define HB_GTCGI_GET(p) ( ( PHB_GTCGI ) HB_GTLOCAL( p ) )
static void hb_gt_cgi_termOut( BYTE * pStr, ULONG ulLen )
typedef struct _HB_GTCGI
{
hb_fsWriteLarge( s_hFilenoStdout, pStr, ulLen );
FHANDLE hStdout;
int iRow;
int iCol;
int iLastCol;
int iLineBufSize;
BYTE * sLineBuf;
char * szCrLf;
ULONG ulCrLf;
BOOL fDispTrans;
PHB_CODEPAGE cdpTerm;
PHB_CODEPAGE cdpHost;
} HB_GTCGI, * PHB_GTCGI;
static void hb_gt_cgi_termOut( PHB_GTCGI pGTCGI, const BYTE * pStr, ULONG ulLen )
{
hb_fsWriteLarge( pGTCGI->hStdout, pStr, ulLen );
}
static void hb_gt_cgi_newLine( void )
static void hb_gt_cgi_newLine( PHB_GTCGI pGTCGI )
{
hb_gt_cgi_termOut( s_szCrLf, s_ulCrLf );
hb_gt_cgi_termOut( pGTCGI, ( BYTE * ) pGTCGI->szCrLf, pGTCGI->ulCrLf );
}
static void hb_gt_cgi_Init( PHB_GT pGT, FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr )
{
PHB_GTCGI pGTCGI;
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Init(%p,%p,%p,%p)", pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr ) );
s_hFilenoStdin = hFilenoStdin;
s_hFilenoStdout = hFilenoStdout;
s_hFilenoStderr = hFilenoStderr;
pGTCGI = ( PHB_GTCGI ) hb_xgrab( sizeof( HB_GTCGI ) );
memset( pGTCGI, 0, sizeof( HB_GTCGI ) );
HB_GTLOCAL( pGT ) = pGTCGI;
s_iRow = s_iCol = s_iLastCol = s_iLineBufSize = 0;
s_cdpTerm = s_cdpHost = NULL;
s_fDispTrans = FALSE;
pGTCGI->hStdout = hFilenoStdout;
s_szCrLf = (BYTE *) hb_conNewLine();
s_ulCrLf = strlen( (char *) s_szCrLf );
pGTCGI->szCrLf = hb_strdup( hb_conNewLine() );
pGTCGI->ulCrLf = strlen( pGTCGI->szCrLf );
hb_fsSetDevMode( s_hFilenoStdout, FD_BINARY );
hb_fsSetDevMode( pGTCGI->hStdout, FD_BINARY );
HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr );
HB_GTSELF_SETFLAG( pGT, GTI_STDOUTCON, TRUE );
@@ -129,20 +131,27 @@ static void hb_gt_cgi_Init( PHB_GT pGT, FHANDLE hFilenoStdin, FHANDLE hFilenoStd
static void hb_gt_cgi_Exit( PHB_GT pGT )
{
PHB_GTCGI pGTCGI;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_cgi_Exit(%p)", pGT));
HB_GTSELF_REFRESH( pGT );
/* update cursor position on exit */
if( s_iLastCol > 0 )
hb_gt_cgi_newLine();
pGTCGI = HB_GTCGI_GET( pGT );
HB_GTSUPER_EXIT( pGT );
if( s_iLineBufSize > 0 )
if( pGTCGI )
{
hb_xfree( s_sLineBuf );
s_iLineBufSize = 0;
/* update cursor position on exit */
if( pGTCGI->iLastCol > 0 )
hb_gt_cgi_newLine( pGTCGI );
if( pGTCGI->iLineBufSize > 0 )
hb_xfree( pGTCGI->sLineBuf );
if( pGTCGI->szCrLf )
hb_xfree( pGTCGI->szCrLf );
hb_xfree( pGTCGI );
}
}
@@ -167,11 +176,14 @@ static BOOL hb_gt_cgi_IsColor( PHB_GT pGT )
static void hb_gt_cgi_Bell( PHB_GT pGT )
{
static const BYTE s_szBell[] = { HB_CHAR_BEL, 0 };
PHB_GTCGI pGTCGI;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_cgi_Bell(%p)", pGT));
HB_SYMBOL_UNUSED( pGT );
pGTCGI = HB_GTCGI_GET( pGT );
hb_gt_cgi_termOut( s_szBell, 1 );
hb_gt_cgi_termOut( pGTCGI, s_szBell, 1 );
}
static char * hb_gt_cgi_Version( PHB_GT pGT, int iType )
@@ -199,13 +211,15 @@ static void hb_gt_cgi_Scroll( PHB_GT pGT, int iTop, int iLeft, int iBottom, int
iTop == 0 && iLeft == 0 &&
iBottom >= iHeight - 1 && iRight >= iWidth - 1 )
{
PHB_GTCGI pGTCGI = HB_GTCGI_GET( pGT );
/* scroll up the internal screen buffer */
HB_GTSELF_SCROLLUP( pGT, iRows, bColor, bChar );
/* update our internal row position */
s_iRow -= iRows;
if( s_iRow < 0 )
s_iRow = 0;
s_iLastCol = s_iCol = 0;
pGTCGI->iRow -= iRows;
if( pGTCGI->iRow < 0 )
pGTCGI->iRow = 0;
pGTCGI->iLastCol = pGTCGI->iCol = 0;
}
else
HB_GTSUPER_SCROLL( pGT, iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols );
@@ -225,9 +239,12 @@ static BOOL hb_gt_cgi_SetDispCP( PHB_GT pGT, char *pszTermCDP, char *pszHostCDP,
if( pszTermCDP && pszHostCDP )
{
s_cdpTerm = hb_cdpFind( pszTermCDP );
s_cdpHost = hb_cdpFind( pszHostCDP );
s_fDispTrans = s_cdpTerm && s_cdpHost && s_cdpTerm != s_cdpHost;
PHB_GTCGI pGTCGI = HB_GTCGI_GET( pGT );
pGTCGI->cdpTerm = hb_cdpFind( pszTermCDP );
pGTCGI->cdpHost = hb_cdpFind( pszHostCDP );
pGTCGI->fDispTrans = pGTCGI->cdpTerm && pGTCGI->cdpHost &&
pGTCGI->cdpTerm != pGTCGI->cdpHost;
return TRUE;
}
#endif
@@ -240,18 +257,19 @@ static BOOL hb_gt_cgi_SetDispCP( PHB_GT pGT, char *pszTermCDP, char *pszHostCDP,
static void hb_gt_cgi_WriteCon( PHB_GT pGT, BYTE * pText, ULONG ulLength )
{
BYTE * buffer = NULL;
PHB_GTCGI pGTCGI = HB_GTCGI_GET( pGT );
#ifndef HB_CDP_SUPPORT_OFF
if( s_fDispTrans )
if( pGTCGI->fDispTrans )
{
buffer = ( BYTE * ) hb_xgrab( ulLength );
memcpy( buffer, pText, ulLength );
hb_cdpnTranslate( ( char * ) buffer, s_cdpHost, s_cdpTerm, ulLength );
hb_cdpnTranslate( ( char * ) buffer, pGTCGI->cdpHost, pGTCGI->cdpTerm, ulLength );
pText = buffer;
}
#endif
hb_gt_cgi_termOut( pText, ulLength );
hb_gt_cgi_termOut( pGTCGI, pText, ulLength );
while( ulLength-- )
{
switch( *pText++ )
@@ -260,23 +278,23 @@ static void hb_gt_cgi_WriteCon( PHB_GT pGT, BYTE * pText, ULONG ulLength )
break;
case HB_CHAR_BS:
if( s_iCol )
s_iCol--;
if( pGTCGI->iCol )
pGTCGI->iCol--;
break;
case HB_CHAR_LF:
s_iRow++;
pGTCGI->iRow++;
break;
case HB_CHAR_CR:
s_iCol = 0;
pGTCGI->iCol = 0;
break;
default:
++s_iCol;
++pGTCGI->iCol;
}
}
HB_GTSUPER_SETPOS( pGT, s_iRow, s_iCol );
HB_GTSUPER_SETPOS( pGT, pGTCGI->iRow, pGTCGI->iCol );
if( buffer )
hb_xfree( buffer );
@@ -285,32 +303,33 @@ static void hb_gt_cgi_WriteCon( PHB_GT pGT, BYTE * pText, ULONG ulLength )
static void hb_gt_cgi_WriteAt( PHB_GT pGT, int iRow, int iCol, BYTE * pText, ULONG ulLength )
{
int iLineFeed = 0, iSpace = 0;
PHB_GTCGI pGTCGI = HB_GTCGI_GET( pGT );
if( s_iRow != iRow )
if( pGTCGI->iRow != iRow )
{
iLineFeed = s_iRow < iRow ? iRow - s_iRow : 1;
iLineFeed = pGTCGI->iRow < iRow ? iRow - pGTCGI->iRow : 1;
}
else if( s_iCol > iCol )
else if( pGTCGI->iCol > iCol )
{
iLineFeed = 1;
iSpace = iCol;
}
else if( s_iCol < iCol )
else if( pGTCGI->iCol < iCol )
{
iSpace = iCol - s_iCol;
iSpace = iCol - pGTCGI->iCol;
}
if( iSpace > 0 )
{
BYTE * buffer = ( BYTE * ) hb_xgrab( iSpace );
memset( buffer, ' ', iSpace );
hb_gt_cgi_termOut( buffer, iSpace );
hb_gt_cgi_termOut( pGTCGI, buffer, iSpace );
hb_xfree( buffer );
}
while( --iLineFeed >= 0 )
hb_gt_cgi_newLine();
s_iRow = iRow;
s_iCol = iCol;
hb_gt_cgi_newLine( pGTCGI );
pGTCGI->iRow = iRow;
pGTCGI->iCol = iCol;
hb_gt_cgi_WriteCon( pGT, pText, ulLength );
}
@@ -322,31 +341,33 @@ static void hb_gt_cgi_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize )
BYTE bColor, bAttr;
USHORT usChar;
int iLineFeed, iHeight, iWidth, iLen;
PHB_GTCGI pGTCGI;
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Redraw(%p,%d,%d,%d)", pGT, iRow, iCol, iSize ) );
pGTCGI = HB_GTCGI_GET( pGT );
HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth );
iLineFeed = iLen = 0;
if( s_iRow != iRow )
if( pGTCGI->iRow != iRow )
{
iLineFeed = s_iRow < iRow ? iRow - s_iRow : 1;
s_iLastCol = s_iCol = iCol = 0;
iLineFeed = pGTCGI->iRow < iRow ? iRow - pGTCGI->iRow : 1;
pGTCGI->iLastCol = pGTCGI->iCol = iCol = 0;
iSize = iWidth;
}
else if( s_iCol < iCol )
else if( pGTCGI->iCol < iCol )
{
iSize += iCol - s_iCol;
iCol = s_iCol;
iSize += iCol - pGTCGI->iCol;
iCol = pGTCGI->iCol;
}
else if( s_iCol > iCol )
else if( pGTCGI->iCol > iCol )
{
iLineFeed = 1;
iCol = s_iCol = s_iLastCol = 0;
iCol = pGTCGI->iCol = pGTCGI->iLastCol = 0;
iSize = iWidth;
}
while( iSize > 0 && iCol + iSize > s_iLastCol &&
while( iSize > 0 && iCol + iSize > pGTCGI->iLastCol &&
HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol + iSize - 1, &bColor, &bAttr, &usChar ) )
{
if( usChar != ' ' )
@@ -357,26 +378,26 @@ static void hb_gt_cgi_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize )
if( iSize > 0 )
{
while( --iLineFeed >= 0 )
hb_gt_cgi_newLine();
s_iRow = iRow;
hb_gt_cgi_newLine( pGTCGI );
pGTCGI->iRow = iRow;
while( iLen < iSize )
{
if( !HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol, &bColor, &bAttr, &usChar ) )
break;
s_sLineBuf[ iLen++ ] = ( BYTE ) usChar;
pGTCGI->sLineBuf[ iLen++ ] = ( BYTE ) usChar;
++iCol;
}
if( iLen )
{
#ifndef HB_CDP_SUPPORT_OFF
if( s_fDispTrans )
hb_cdpnTranslate( ( char * ) s_sLineBuf, s_cdpHost, s_cdpTerm, iLen );
if( pGTCGI->fDispTrans )
hb_cdpnTranslate( ( char * ) pGTCGI->sLineBuf, pGTCGI->cdpHost, pGTCGI->cdpTerm, iLen );
#endif
hb_gt_cgi_termOut( s_sLineBuf, iLen );
s_iCol = iCol;
if( s_iCol > s_iLastCol )
s_iLastCol = s_iCol;
hb_gt_cgi_termOut( pGTCGI, pGTCGI->sLineBuf, iLen );
pGTCGI->iCol = iCol;
if( pGTCGI->iCol > pGTCGI->iLastCol )
pGTCGI->iLastCol = pGTCGI->iCol;
}
}
}
@@ -384,19 +405,21 @@ static void hb_gt_cgi_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize )
static void hb_gt_cgi_Refresh( PHB_GT pGT )
{
int iHeight, iWidth;
PHB_GTCGI pGTCGI;
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Refresh(%p)", pGT ) );
pGTCGI = HB_GTCGI_GET( pGT );
HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth );
if( s_iLineBufSize == 0 )
if( pGTCGI->iLineBufSize == 0 )
{
s_sLineBuf = ( BYTE * ) hb_xgrab( iWidth );
s_iLineBufSize = iWidth;
pGTCGI->sLineBuf = ( BYTE * ) hb_xgrab( iWidth );
pGTCGI->iLineBufSize = iWidth;
}
else if( s_iLineBufSize < iWidth )
else if( pGTCGI->iLineBufSize < iWidth )
{
s_sLineBuf = ( BYTE * ) hb_xrealloc( s_sLineBuf, iWidth );
s_iLineBufSize = iWidth;
pGTCGI->sLineBuf = ( BYTE * ) hb_xrealloc( pGTCGI->sLineBuf, iWidth );
pGTCGI->iLineBufSize = iWidth;
}
HB_GTSUPER_REFRESH( pGT );
}
@@ -432,10 +455,10 @@ static BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable )
/* ********************************************************************** */
static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
static const HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
HB_GT_ANNOUNCE( HB_GT_NAME )

8
harbour/source/rtl/gtcrs/gtcrs.c
View File

@@ -3001,10 +3001,10 @@ static BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable )
/* ********************************************************************** */
static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
static const HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
HB_GT_ANNOUNCE( HB_GT_NAME )

8
harbour/source/rtl/gtdos/gtdos.c
View File

@@ -1598,10 +1598,10 @@ static BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable )
/* ********************************************************************** */
static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
static const HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
HB_GT_ANNOUNCE( HB_GT_NAME )

8
harbour/source/rtl/gtgui/gtgui.c
View File

@@ -156,10 +156,10 @@ static BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable )
/* ********************************************************************** */
static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
static const HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
HB_GT_ANNOUNCE( HB_GT_NAME )

8
harbour/source/rtl/gtos2/gtos2.c
View File

@@ -987,10 +987,10 @@ static BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable )
/* ********************************************************************** */
static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
static const HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
HB_GT_ANNOUNCE( HB_GT_NAME )

8
harbour/source/rtl/gtpca/gtpca.c
View File

@@ -992,10 +992,10 @@ static BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable )
/* ********************************************************************** */
static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
static const HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
HB_GT_ANNOUNCE( HB_GT_NAME )

8
harbour/source/rtl/gtsln/gtsln.c
View File

@@ -1051,10 +1051,10 @@ static BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable )
/* ********************************************************************** */
static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
static const HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
HB_GT_ANNOUNCE( HB_GT_NAME )

358
harbour/source/rtl/gtstd/gtstd.c
View File

@@ -85,31 +85,48 @@ static HB_GT_FUNCS SuperTable;
#define HB_GTSUPER (&SuperTable)
#define HB_GTID_PTR (&s_GtId)
static const BYTE s_szBell[] = { HB_CHAR_BEL, 0 };
static const BYTE * s_szCrLf;
static ULONG s_ulCrLf;
#define HB_GTSTD_GET(p) ( ( PHB_GTSTD ) HB_GTLOCAL( p ) )
static const BYTE s_szBell[] = { HB_CHAR_BEL, 0 };
typedef struct _HB_GTSTD
{
FHANDLE hStdin;
FHANDLE hStdout;
FHANDLE hStderr;
BOOL fStdinConsole;
BOOL fStdoutConsole;
BOOL fStderrConsole;
int iRow;
int iCol;
int iLastCol;
int iLineBufSize;
BYTE * sLineBuf;
BOOL fFullRedraw;
char * szCrLf;
ULONG ulCrLf;
BOOL fDispTrans;
PHB_CODEPAGE cdpTerm;
PHB_CODEPAGE cdpHost;
BYTE keyTransTbl[ 256 ];
#if defined( OS_UNIX_COMPATIBLE )
struct termios saved_TIO;
struct termios curr_TIO;
BOOL fRestTTY;
#endif
double dToneSeconds;
} HB_GTSTD, * PHB_GTSTD;
static FHANDLE s_hFilenoStdin;
static FHANDLE s_hFilenoStdout;
static FHANDLE s_hFilenoStderr;
static int s_iRow;
static int s_iCol;
static int s_iLastCol;
static int s_iLineBufSize;
static BYTE * s_sLineBuf;
static BOOL s_bFullRedraw;
static BOOL s_bStdinConsole;
static BOOL s_bStdoutConsole;
static BOOL s_bStderrConsole;
static BOOL s_fDispTrans;
static PHB_CODEPAGE s_cdpTerm;
static PHB_CODEPAGE s_cdpHost;
static BYTE s_keyTransTbl[ 256 ];
#if defined( OS_UNIX_COMPATIBLE )
static volatile BOOL s_fRestTTY = FALSE;
static struct termios s_saved_TIO, s_curr_TIO;
static void sig_handler( int iSigNo )
{
@@ -142,65 +159,68 @@ static void sig_handler( int iSigNo )
#endif
static void hb_gt_std_setKeyTrans( char * pSrcChars, char * pDstChars )
static void hb_gt_std_setKeyTrans( PHB_GTSTD pGTSTD, char * pSrcChars, char * pDstChars )
{
int i;
for( i = 0; i < 256; ++i )
s_keyTransTbl[ i ] = ( BYTE ) i;
pGTSTD->keyTransTbl[ i ] = ( BYTE ) i;
if( pSrcChars && pDstChars )
{
BYTE c;
for( i = 0; i < 256 && ( c = ( BYTE ) pSrcChars[ i ] ) != 0; ++i )
s_keyTransTbl[ c ] = ( BYTE ) pDstChars[ i ];
pGTSTD->keyTransTbl[ c ] = ( BYTE ) pDstChars[ i ];
}
}
static void hb_gt_std_termOut( const BYTE * pStr, ULONG ulLen )
static void hb_gt_std_termOut( PHB_GTSTD pGTSTD, const BYTE * pStr, ULONG ulLen )
{
hb_fsWriteLarge( s_hFilenoStdout, pStr, ulLen );
hb_fsWriteLarge( pGTSTD->hStdout, pStr, ulLen );
}
static void hb_gt_std_newLine( void )
static void hb_gt_std_newLine( PHB_GTSTD pGTSTD )
{
hb_gt_std_termOut( s_szCrLf, s_ulCrLf );
hb_gt_std_termOut( pGTSTD, ( BYTE * ) pGTSTD->szCrLf, pGTSTD->ulCrLf );
}
static void hb_gt_std_Init( PHB_GT pGT, FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr )
{
PHB_GTSTD pGTSTD;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_std_Init(%p,%p,%p,%p)", pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr));
s_hFilenoStdin = hFilenoStdin;
s_hFilenoStdout = hFilenoStdout;
s_hFilenoStderr = hFilenoStderr;
pGTSTD = ( PHB_GTSTD ) hb_xgrab( sizeof( HB_GTSTD ) );
memset( pGTSTD, 0, sizeof( HB_GTSTD ) );
HB_GTLOCAL( pGT ) = pGTSTD;
s_bStdinConsole = hb_fsIsDevice( s_hFilenoStdin );
s_bStdoutConsole = hb_fsIsDevice( s_hFilenoStdout );
s_bStderrConsole = hb_fsIsDevice( s_hFilenoStderr );
pGTSTD->hStdin = hFilenoStdin;
pGTSTD->hStdout = hFilenoStdout;
pGTSTD->hStderr = hFilenoStderr;
s_iRow = s_iCol = s_iLastCol = s_iLineBufSize = 0;
s_cdpTerm = s_cdpHost = NULL;
s_fDispTrans = FALSE;
hb_gt_std_setKeyTrans( NULL, NULL );
pGTSTD->fStdinConsole = hb_fsIsDevice( pGTSTD->hStdin );
pGTSTD->fStdoutConsole = hb_fsIsDevice( pGTSTD->hStdout );
pGTSTD->fStderrConsole = hb_fsIsDevice( pGTSTD->hStderr );
s_szCrLf = ( BYTE * ) hb_conNewLine();
s_ulCrLf = strlen( ( char * ) s_szCrLf );
hb_gt_std_setKeyTrans( pGTSTD, NULL, NULL );
hb_fsSetDevMode( s_hFilenoStdout, FD_BINARY );
pGTSTD->szCrLf = hb_strdup( hb_conNewLine() );
pGTSTD->ulCrLf = strlen( pGTSTD->szCrLf );
hb_fsSetDevMode( pGTSTD->hStdout, FD_BINARY );
HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr );
/* SA_NOCLDSTOP in #if is a hack to detect POSIX compatible environment */
#if defined( OS_UNIX_COMPATIBLE ) && defined( SA_NOCLDSTOP )
s_fRestTTY = FALSE;
if( s_bStdinConsole )
if( pGTSTD->fStdinConsole )
{
struct sigaction act, old;
s_fRestTTY = TRUE;
/* if( s_saved_TIO.c_lflag & TOSTOP ) != 0 */
/* if( pGTSTD->saved_TIO.c_lflag & TOSTOP ) != 0 */
sigaction( SIGTTOU, NULL, &old );
memcpy( &act, &old, sizeof( struct sigaction ) );
act.sa_handler = sig_handler;
@@ -214,92 +234,100 @@ static void hb_gt_std_Init( PHB_GT pGT, FHANDLE hFilenoStdin, FHANDLE hFilenoStd
#endif
sigaction( SIGTTOU, &act, 0 );
tcgetattr( hFilenoStdin, &s_saved_TIO );
memcpy( &s_curr_TIO, &s_saved_TIO, sizeof( struct termios ) );
tcgetattr( pGTSTD->hStdin, &pGTSTD->saved_TIO );
memcpy( &pGTSTD->curr_TIO, &pGTSTD->saved_TIO, sizeof( struct termios ) );
/* atexit( restore_input_mode ); */
s_curr_TIO.c_lflag &= ~( ICANON | ECHO );
s_curr_TIO.c_iflag &= ~ICRNL;
s_curr_TIO.c_cc[ VMIN ] = 0;
s_curr_TIO.c_cc[ VTIME ] = 0;
tcsetattr( hFilenoStdin, TCSAFLUSH, &s_curr_TIO );
pGTSTD->curr_TIO.c_lflag &= ~( ICANON | ECHO );
pGTSTD->curr_TIO.c_iflag &= ~ICRNL;
pGTSTD->curr_TIO.c_cc[ VMIN ] = 0;
pGTSTD->curr_TIO.c_cc[ VTIME ] = 0;
tcsetattr( pGTSTD->hStdin, TCSAFLUSH, &pGTSTD->curr_TIO );
act.sa_handler = SIG_DFL;
sigaction( SIGTTOU, &old, NULL );
pGTSTD->fRestTTY = s_fRestTTY;
}
if( s_bStdoutConsole )
if( pGTSTD->fStdoutConsole )
{
struct winsize win;
if( ioctl( hFilenoStdout, TIOCGWINSZ, ( char * ) &win ) != -1 )
if( ioctl( pGTSTD->hStdout, TIOCGWINSZ, ( char * ) &win ) != -1 )
{
HB_GTSELF_RESIZE( pGT, win.ws_row, win.ws_col );
}
}
#elif defined( HB_WIN32_IO ) && ! defined( HB_WINCE )
if( s_bStdinConsole )
if( pGTSTD->fStdinConsole )
{
SetConsoleMode( ( HANDLE ) hb_fsGetOsHandle( s_hFilenoStdin ), 0x0000 );
SetConsoleMode( ( HANDLE ) hb_fsGetOsHandle( pGTSTD->hStdin ), 0x0000 );
}
#endif
HB_GTSELF_SETFLAG( pGT, GTI_STDOUTCON, s_bStdoutConsole );
HB_GTSELF_SETFLAG( pGT, GTI_STDERRCON, s_bStderrConsole );
HB_GTSELF_SETFLAG( pGT, GTI_STDOUTCON, pGTSTD->fStdoutConsole );
HB_GTSELF_SETFLAG( pGT, GTI_STDERRCON, pGTSTD->fStderrConsole );
}
static void hb_gt_std_Exit( PHB_GT pGT )
{
PHB_GTSTD pGTSTD;
int iRow, iCol;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_std_Exit(%p)", pGT));
HB_GTSELF_REFRESH( pGT );
/* update cursor position on exit */
if( s_bStdoutConsole && s_iLastCol > 0 )
{
hb_gt_std_newLine();
++s_iRow;
}
HB_GTSELF_GETPOS( pGT, &iRow, &iCol );
while( ++s_iRow <= iRow )
hb_gt_std_newLine();
pGTSTD = HB_GTSTD_GET( pGT );
HB_GTSUPER_EXIT( pGT );
#if defined( OS_UNIX_COMPATIBLE )
if( s_fRestTTY )
tcsetattr( s_hFilenoStdin, TCSANOW, &s_saved_TIO );
#endif
if( s_iLineBufSize > 0 )
if( pGTSTD )
{
hb_xfree( s_sLineBuf );
s_iLineBufSize = 0;
/* update cursor position on exit */
if( pGTSTD->fStdoutConsole && pGTSTD->iLastCol > 0 )
{
hb_gt_std_newLine( pGTSTD );
++pGTSTD->iRow;
}
while( ++pGTSTD->iRow <= iRow )
hb_gt_std_newLine( pGTSTD );
#if defined( OS_UNIX_COMPATIBLE )
if( pGTSTD->fRestTTY )
tcsetattr( pGTSTD->hStdin, TCSANOW, &pGTSTD->saved_TIO );
#endif
if( pGTSTD->iLineBufSize > 0 )
hb_xfree( pGTSTD->sLineBuf );
if( pGTSTD->szCrLf )
hb_xfree( pGTSTD->szCrLf );
hb_xfree( pGTSTD );
}
s_bStdinConsole = s_bStdoutConsole = s_bStderrConsole = FALSE;
}
static int hb_gt_std_ReadKey( PHB_GT pGT, int iEventMask )
{
PHB_GTSTD pGTSTD;
int ch = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_std_ReadKey(%p,%d)", pGT, iEventMask));
HB_SYMBOL_UNUSED( pGT );
HB_SYMBOL_UNUSED( iEventMask );
pGTSTD = HB_GTSTD_GET( pGT );
#if defined( _MSC_VER ) && !defined( HB_WINCE )
if( s_bStdinConsole )
if( pGTSTD->fStdinConsole )
{
if( _kbhit() ) ch = _getch();
if( ch >= 0 && ch <= 255 )
ch = s_keyTransTbl[ ch ];
ch = pGTSTD->keyTransTbl[ ch ];
}
else if( !_eof( s_hFilenoStdin ) )
else if( !_eof( pGTSTD->hStdin ) )
{
BYTE bChar;
if( _read( s_hFilenoStdin, &bChar, 1 ) == 1 )
ch = s_keyTransTbl[ bChar ];
if( _read( pGTSTD->hStdin, &bChar, 1 ) == 1 )
ch = pGTSTD->keyTransTbl[ bChar ];
}
#elif defined( OS_UNIX_COMPATIBLE ) || defined( __DJGPP__ )
{
@@ -308,21 +336,21 @@ static int hb_gt_std_ReadKey( PHB_GT pGT, int iEventMask )
tv.tv_sec = 0;
tv.tv_usec = 0;
FD_ZERO( &rfds );
FD_SET( s_hFilenoStdin, &rfds);
if( select( s_hFilenoStdin + 1, &rfds, NULL, NULL, &tv ) > 0 )
FD_SET( pGTSTD->hStdin, &rfds);
if( select( pGTSTD->hStdin + 1, &rfds, NULL, NULL, &tv ) > 0 )
{
BYTE bChar;
if( hb_fsRead( s_hFilenoStdin, &bChar, 1 ) == 1 )
ch = s_keyTransTbl[ bChar ];
if( hb_fsRead( pGTSTD->hStdin, &bChar, 1 ) == 1 )
ch = pGTSTD->keyTransTbl[ bChar ];
}
}
#elif defined( HB_WIN32_IO )
if( !s_bStdinConsole ||
WaitForSingleObject( ( HANDLE ) hb_fsGetOsHandle( s_hFilenoStdin ), 0 ) == 0x0000 )
if( !pGTSTD->fStdinConsole ||
WaitForSingleObject( ( HANDLE ) hb_fsGetOsHandle( pGTSTD->hStdin ), 0 ) == 0x0000 )
{
BYTE bChar;
if( hb_fsRead( s_hFilenoStdin, &bChar, 1 ) == 1 )
ch = s_keyTransTbl[ bChar ];
if( hb_fsRead( pGTSTD->hStdin, &bChar, 1 ) == 1 )
ch = pGTSTD->keyTransTbl[ bChar ];
}
#else
{
@@ -344,12 +372,12 @@ static BOOL hb_gt_std_IsColor( PHB_GT pGT )
static void hb_gt_std_Tone( PHB_GT pGT, double dFrequency, double dDuration )
{
static double dLastSeconds = 0;
double dCurrentSeconds;
PHB_GTSTD pGTSTD;
HB_TRACE(HB_TR_DEBUG, ("hb_gt_std_Tone(%p,%lf,%lf)", pGT, dFrequency, dDuration));
HB_SYMBOL_UNUSED( pGT );
pGTSTD = HB_GTSTD_GET( pGT );
/* Output an ASCII BEL character to cause a sound */
/* but throttle to max once per second, in case of sound */
@@ -357,10 +385,11 @@ static void hb_gt_std_Tone( PHB_GT pGT, double dFrequency, double dDuration )
/* succession leading to BEL hell on the terminal */
dCurrentSeconds = hb_dateSeconds();
if( dCurrentSeconds < dLastSeconds || dCurrentSeconds - dLastSeconds > 0.5 )
if( dCurrentSeconds < pGTSTD->dToneSeconds ||
dCurrentSeconds - pGTSTD->dToneSeconds > 0.5 )
{
hb_gt_std_termOut( s_szBell, 1 );
dLastSeconds = dCurrentSeconds;
hb_gt_std_termOut( pGTSTD, s_szBell, 1 );
pGTSTD->dToneSeconds = dCurrentSeconds;
}
HB_SYMBOL_UNUSED( dFrequency );
@@ -373,9 +402,7 @@ static void hb_gt_std_Bell( PHB_GT pGT )
{
HB_TRACE(HB_TR_DEBUG, ( "hb_gt_std_Bell(%p)", pGT ) );
HB_SYMBOL_UNUSED( pGT );
hb_gt_std_termOut( s_szBell, 1 );
hb_gt_std_termOut( HB_GTSTD_GET( pGT ), s_szBell, 1 );
}
static char * hb_gt_std_Version( PHB_GT pGT, int iType )
@@ -394,30 +421,30 @@ static BOOL hb_gt_std_Suspend( PHB_GT pGT )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Suspend(%p)", pGT ) );
HB_SYMBOL_UNUSED( pGT );
#if defined( OS_UNIX_COMPATIBLE )
if( s_fRestTTY )
{
tcsetattr( s_hFilenoStdin, TCSANOW, &s_saved_TIO );
PHB_GTSTD pGTSTD = HB_GTSTD_GET( pGT );
if( pGTSTD->fRestTTY )
tcsetattr( pGTSTD->hStdin, TCSANOW, &pGTSTD->saved_TIO );
}
#endif
return TRUE;
return HB_GTSUPER_SUSPEND( pGT );
}
static BOOL hb_gt_std_Resume( PHB_GT pGT )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Resume(%p)", pGT ) );
HB_SYMBOL_UNUSED( pGT );
#if defined( OS_UNIX_COMPATIBLE )
if( s_fRestTTY )
{
tcsetattr( s_hFilenoStdin, TCSANOW, &s_curr_TIO );
PHB_GTSTD pGTSTD = HB_GTSTD_GET( pGT );
if( pGTSTD->fRestTTY )
tcsetattr( pGTSTD->hStdin, TCSANOW, &pGTSTD->curr_TIO );
}
#endif
return TRUE;
return HB_GTSUPER_RESUME( pGT );
}
static void hb_gt_std_Scroll( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight,
@@ -433,12 +460,14 @@ static void hb_gt_std_Scroll( PHB_GT pGT, int iTop, int iLeft, int iBottom, int
iTop == 0 && iLeft == 0 &&
iBottom >= iHeight - 1 && iRight >= iWidth - 1 )
{
PHB_GTSTD pGTSTD;
/* scroll up the internal screen buffer */
HB_GTSELF_SCROLLUP( pGT, iRows, bColor, bChar );
/* update our internal row position */
s_iRow -= iRows;
if( s_iRow < 0 )
s_iRow = 0;
pGTSTD = HB_GTSTD_GET( pGT );
pGTSTD->iRow -= iRows;
if( pGTSTD->iRow < 0 )
pGTSTD->iRow = 0;
}
else
HB_GTSUPER_SCROLL( pGT, iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols );
@@ -458,9 +487,11 @@ static BOOL hb_gt_std_SetDispCP( PHB_GT pGT, char *pszTermCDP, char *pszHostCDP,
if( pszTermCDP && pszHostCDP )
{
s_cdpTerm = hb_cdpFind( pszTermCDP );
s_cdpHost = hb_cdpFind( pszHostCDP );
s_fDispTrans = s_cdpTerm && s_cdpHost && s_cdpTerm != s_cdpHost;
PHB_GTSTD pGTSTD = HB_GTSTD_GET( pGT );
pGTSTD->cdpTerm = hb_cdpFind( pszTermCDP );
pGTSTD->cdpHost = hb_cdpFind( pszHostCDP );
pGTSTD->fDispTrans = pGTSTD->cdpTerm && pGTSTD->cdpHost &&
pGTSTD->cdpTerm != pGTSTD->cdpHost;
return TRUE;
}
#endif
@@ -495,13 +526,13 @@ static BOOL hb_gt_std_SetKeyCP( PHB_GT pGT, char *pszTermCDP, char *pszHostCDP )
strncpy( pszTermLetters, cdpTerm->CharsUpper, cdpTerm->nChars + 1 );
strncat( pszTermLetters, cdpTerm->CharsLower, cdpTerm->nChars + 1 );
hb_gt_std_setKeyTrans( pszTermLetters, pszHostLetters );
hb_gt_std_setKeyTrans( HB_GTSTD_GET( pGT ), pszTermLetters, pszHostLetters );
hb_xfree( pszHostLetters );
hb_xfree( pszTermLetters );
}
else
hb_gt_std_setKeyTrans( NULL, NULL );
hb_gt_std_setKeyTrans( HB_GTSTD_GET( pGT ), NULL, NULL );
return TRUE;
}
@@ -515,22 +546,23 @@ static void hb_gt_std_DispLine( PHB_GT pGT, int iRow )
BYTE bColor, bAttr;
USHORT usChar;
int iCol, iMin = 0;
PHB_GTSTD pGTSTD = HB_GTSTD_GET( pGT );
for( iCol = 0; iCol < s_iLineBufSize; ++iCol )
for( iCol = 0; iCol < pGTSTD->iLineBufSize; ++iCol )
{
if( !HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol, &bColor, &bAttr, &usChar ) )
break;
if( usChar < 32 || usChar == 127 )
usChar = '.';
s_sLineBuf[ iCol ] = ( BYTE ) usChar;
pGTSTD->sLineBuf[ iCol ] = ( BYTE ) usChar;
if( usChar != ' ' )
iMin = iCol + 1;
}
hb_gt_std_newLine();
hb_gt_std_newLine( pGTSTD );
if( iMin > 0 )
hb_gt_std_termOut( s_sLineBuf, iMin );
s_iLastCol = s_iCol = iMin;
s_iRow = iRow;
hb_gt_std_termOut( pGTSTD, pGTSTD->sLineBuf, iMin );
pGTSTD->iLastCol = pGTSTD->iCol = iMin;
pGTSTD->iRow = iRow;
}
static void hb_gt_std_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize )
@@ -538,27 +570,29 @@ static void hb_gt_std_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize )
BYTE bColor, bAttr;
USHORT usChar;
int iLineFeed, iBackSpace, iLen, iMin;
PHB_GTSTD pGTSTD;
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Redraw(%p,%d,%d,%d)", pGT, iRow, iCol, iSize ) );
iLineFeed = iBackSpace = 0;
pGTSTD = HB_GTSTD_GET( pGT );
if( s_iRow != iRow )
if( pGTSTD->iRow != iRow )
{
iLineFeed = s_iRow < iRow ? iRow - s_iRow : 1;
iLineFeed = pGTSTD->iRow < iRow ? iRow - pGTSTD->iRow : 1;
iCol = 0;
iSize = s_iLineBufSize;
iSize = pGTSTD->iLineBufSize;
}
else if( s_iCol < iCol )
else if( pGTSTD->iCol < iCol )
{
iSize += iCol - s_iCol;
iCol = s_iCol;
iSize += iCol - pGTSTD->iCol;
iCol = pGTSTD->iCol;
}
else if( s_iCol > iCol )
else if( pGTSTD->iCol > iCol )
{
if( s_bStdoutConsole && s_iCol <= s_iLineBufSize )
if( pGTSTD->fStdoutConsole && pGTSTD->iCol <= pGTSTD->iLineBufSize )
{
iBackSpace = s_iCol - iCol;
iBackSpace = pGTSTD->iCol - iCol;
if( iBackSpace > iSize )
iSize = iBackSpace;
}
@@ -566,11 +600,11 @@ static void hb_gt_std_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize )
{
iLineFeed = 1;
iCol = 0;
iSize = s_iLineBufSize;
iSize = pGTSTD->iLineBufSize;
}
}
iMin = iLineFeed > 0 || s_iLastCol <= iCol ? 0 : s_iLastCol - iCol;
iMin = iLineFeed > 0 || pGTSTD->iLastCol <= iCol ? 0 : pGTSTD->iLastCol - iCol;
while( iSize > iMin &&
HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol + iSize - 1, &bColor, &bAttr, &usChar ) )
@@ -588,29 +622,29 @@ static void hb_gt_std_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize )
* If you want to disable full screen redrawing in console (TTY)
* output then comment out the 'if' block below, Druzus
*/
if( s_bStdoutConsole )
if( pGTSTD->fStdoutConsole )
{
int i;
if( s_iRow > iRow )
if( pGTSTD->iRow > iRow )
{
s_iRow = -1;
s_bFullRedraw = TRUE;
pGTSTD->iRow = -1;
pGTSTD->fFullRedraw = TRUE;
}
for( i = s_iRow + 1; i < iRow; ++i )
for( i = pGTSTD->iRow + 1; i < iRow; ++i )
hb_gt_std_DispLine( pGT, i );
iLineFeed = 1;
}
do
hb_gt_std_newLine();
hb_gt_std_newLine( pGTSTD );
while( --iLineFeed );
s_iLastCol = 0;
pGTSTD->iLastCol = 0;
}
else if( iBackSpace > 0 )
{
memset( s_sLineBuf, HB_CHAR_BS, iBackSpace );
hb_gt_std_termOut( s_sLineBuf, iBackSpace );
memset( pGTSTD->sLineBuf, HB_CHAR_BS, iBackSpace );
hb_gt_std_termOut( pGTSTD, pGTSTD->sLineBuf, iBackSpace );
}
for( iLen = 0; iLen < iSize; ++iLen )
@@ -619,51 +653,53 @@ static void hb_gt_std_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize )
break;
if( usChar < 32 || usChar == 127 )
usChar = '.';
s_sLineBuf[ iLen ] = ( BYTE ) usChar;
pGTSTD->sLineBuf[ iLen ] = ( BYTE ) usChar;
++iCol;
}
if( iLen )
{
#ifndef HB_CDP_SUPPORT_OFF
if( s_fDispTrans )
hb_cdpnTranslate( ( char * ) s_sLineBuf, s_cdpHost, s_cdpTerm, iLen );
if( pGTSTD->fDispTrans )
hb_cdpnTranslate( ( char * ) pGTSTD->sLineBuf, pGTSTD->cdpHost, pGTSTD->cdpTerm, iLen );
#endif
hb_gt_std_termOut( s_sLineBuf, iLen );
hb_gt_std_termOut( pGTSTD, pGTSTD->sLineBuf, iLen );
}
s_iRow = iRow;
s_iCol = iCol;
if( s_iCol > s_iLastCol )
s_iLastCol = s_iCol;
pGTSTD->iRow = iRow;
pGTSTD->iCol = iCol;
if( pGTSTD->iCol > pGTSTD->iLastCol )
pGTSTD->iLastCol = pGTSTD->iCol;
}
}
static void hb_gt_std_Refresh( PHB_GT pGT )
{
int iHeight, iWidth;
PHB_GTSTD pGTSTD;
HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Refresh(%p)", pGT ) );
HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth );
if( s_iLineBufSize == 0 )
pGTSTD = HB_GTSTD_GET( pGT );
if( pGTSTD->iLineBufSize == 0 )
{
s_sLineBuf = ( BYTE * ) hb_xgrab( iWidth );
s_iLineBufSize = iWidth;
pGTSTD->sLineBuf = ( BYTE * ) hb_xgrab( iWidth );
pGTSTD->iLineBufSize = iWidth;
}
else if( s_iLineBufSize != iWidth )
else if( pGTSTD->iLineBufSize != iWidth )
{
s_sLineBuf = ( BYTE * ) hb_xrealloc( s_sLineBuf, iWidth );
s_iLineBufSize = iWidth;
pGTSTD->sLineBuf = ( BYTE * ) hb_xrealloc( pGTSTD->sLineBuf, iWidth );
pGTSTD->iLineBufSize = iWidth;
}
s_bFullRedraw = FALSE;
pGTSTD->fFullRedraw = FALSE;
HB_GTSUPER_REFRESH( pGT );
if( s_bFullRedraw )
if( pGTSTD->fFullRedraw )
{
int i;
if( s_iRow < iHeight - 1 )
if( pGTSTD->iRow < iHeight - 1 )
{
for( i = s_iRow + 1; i < iHeight; ++i )
for( i = pGTSTD->iRow + 1; i < iHeight; ++i )
hb_gt_std_DispLine( pGT, i );
}
}
@@ -714,10 +750,10 @@ static BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable )
/* ********************************************************************** */
static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
static const HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
HB_GT_ANNOUNCE( HB_GT_NAME )

10
harbour/source/rtl/gttrm/gttrm.c
View File

@@ -2876,7 +2876,7 @@ static void hb_gt_trm_Init( PHB_GT pGT, FHANDLE hFilenoStdin, FHANDLE hFilenoStd
tcsetattr( pTerm->hFilenoStdin, TCSAFLUSH, &pTerm->curr_TIO );
act.sa_handler = SIG_DFL;
sigaction( SIGTTOU, &old, 0 );
sigaction( SIGTTOU, &old, NULL );
pTerm->fRestTTY = s_fRestTTY;
}
set_signals();
@@ -3441,10 +3441,10 @@ static BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable )
/* ********************************************************************** */
static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
static const HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
HB_GT_ANNOUNCE( HB_GT_NAME )

8
harbour/source/rtl/gtwin/gtwin.c
View File

@@ -1809,10 +1809,10 @@ static BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable )
/* ********************************************************************** */
static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
static const HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
HB_GT_ANNOUNCE( HB_GT_NAME )

8
harbour/source/rtl/gtwvt/gtwvt.c
View File

@@ -2081,10 +2081,10 @@ static BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable )
/* ********************************************************************** */
static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
static const HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
HB_GT_ANNOUNCE( HB_GT_NAME )

8
harbour/source/rtl/gtxwc/gtxwc.c
View File

@@ -4051,10 +4051,10 @@ static BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable )
/* ********************************************************************** */
static HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
static const HB_GT_INIT gtInit = { HB_GT_DRVNAME( HB_GT_NAME ),
hb_gt_FuncInit,
HB_GTSUPER,
HB_GTID_PTR };
HB_GT_ANNOUNCE( HB_GT_NAME )

14
harbour/source/rtl/hbgtcore.c
View File

@@ -2989,7 +2989,7 @@ static char s_gtNameBuf[ HB_GT_NAME_MAX_ + 1 ];
const char * s_defaultGT = "std";
#endif
static PHB_GT_INIT s_gtInit[ HB_GT_MAX_ ];
static const HB_GT_INIT * s_gtInit[ HB_GT_MAX_ ];
static int s_gtLinkOrder[ HB_GT_MAX_ ];
static int s_iGtLinkCount = 0;
static int s_iGtCount = 0;
@@ -3036,7 +3036,7 @@ HB_EXPORT void hb_gtSetDefault( const char * szGtName )
s_defaultGT = s_gtNameBuf;
}
HB_EXPORT BOOL hb_gtRegister( PHB_GT_INIT gtInit )
HB_EXPORT BOOL hb_gtRegister( const HB_GT_INIT * gtInit )
{
if( hb_gt_FindEntry( gtInit->id ) == -1 )
{
@@ -3053,7 +3053,17 @@ HB_EXPORT BOOL hb_gtLoad( const char * szGtName, PHB_GT_FUNCS pFuncTable )
if( szGtName )
{
if( hb_stricmp( szGtName, "nul" ) == 0 || hb_stricmp( szGtName, "null" ) == 0 )
{
if( pFuncTable == NULL )
pFuncTable = &s_gtCoreFunc;
if( !s_curGT )
{
s_curGT = ( PHB_GT_BASE ) hb_xgrab( sizeof( HB_GT_BASE ) );
memset( s_curGT, 0, sizeof( HB_GT_BASE ) );
}
s_curGT->pFuncTable = pFuncTable;
return TRUE;
}
iPos = hb_gt_FindEntry( szGtName );