diff --git a/harbour/ChangeLog b/harbour/ChangeLog index 6745c20fc8..fecfdc1ae2 100644 --- a/harbour/ChangeLog +++ b/harbour/ChangeLog @@ -8,6 +8,50 @@ 2002-12-01 13:30 UTC+0100 Foo Bar */ +2007-12-07 10:43 UTC+0100 Przemyslaw Czerpak (druzus/at/priv.onet.pl) + * harbour/include/hbgtcore.h + * harbour/source/rtl/hbgtcore.c + * harbour/source/rtl/gtapi.c + * harbour/source/rtl/inkeyapi.c + * harbour/source/rtl/mouseapi.c + - removed hb_gt_*(), hb_inkey_*(), hb_mouse_*() functions + + implemented HB_GTSELF_*() functions and changed HB_GTSUPER_*() + ones to operate on GT context passed ad 1-st parameter. + Now GT API allows to create many GTs working simultaneously + + added hb_gt_Base() core function which returns GT context + it will be extended soon to allow using many GT contexts, + setting thread default one or switch between them using some + .prg function. + + * harbour/source/rtl/gtstd/gtstd.c + * harbour/source/rtl/gtcgi/gtcgi.c + * harbour/source/rtl/gtpca/gtpca.c + * harbour/source/rtl/gttrm/gttrm.c + * harbour/source/rtl/gtxwc/gtxwc.c + * harbour/source/rtl/gtcrs/gtcrs.c + * harbour/source/rtl/gtcrs/gtcrs.h + * harbour/source/rtl/gtsln/gtsln.c + * harbour/source/rtl/gtsln/gtsln.h + * harbour/source/rtl/gtsln/kbsln.c + * harbour/source/rtl/gtsln/mousesln.c + * harbour/source/rtl/gtalleg/gtalleg.c + * harbour/source/rtl/gtgui/gtgui.c + * harbour/source/rtl/gtwin/gtwin.c + * harbour/source/rtl/gtwvt/gtwvt.h + * harbour/source/rtl/gtwvt/gtwvt.c + * harbour/contrib/hbct/ctwin.c + * harbour/contrib/hbct/ctwin.h + * harbour/contrib/hbct/ctwfunc.c + * harbour/contrib/hbgtwvg/gtwvt.h + * harbour/contrib/hbgtwvg/gtwvt.c + * updated GT code for new GT API. I still haven't added GT cloning + to them and only GTTRM is ready to use in multi window MT programs + but now they can be systematically modified and it can be done + locally without core code modifications. + + * harbour/contrib/hbgtwvg/wvtutils.c + ! fixed some memory leaks in Unicode conversions + 2007-12-06 11:35 UTC+0200 Mindaugas Kavaliauskas (dbtopas/at/dbtopas.lt) * harbour/source/lang/msgltwin.c * more changes from LT to LTWIN diff --git a/harbour/contrib/hbct/ctwfunc.c b/harbour/contrib/hbct/ctwfunc.c index 0874ef5265..f8e7933c5c 100644 --- a/harbour/contrib/hbct/ctwfunc.c +++ b/harbour/contrib/hbct/ctwfunc.c @@ -56,7 +56,7 @@ HB_FUNC( CTWINIT ) { - hb_retl( hb_ctw_Init() ); + hb_retl( hb_ctwInit() ); } HB_FUNC( GETCLEARA ) @@ -97,86 +97,66 @@ HB_FUNC( GETCLEARB ) HB_FUNC( WSETSHADOW ) { - hb_retni( hb_ctw_SetShadowAttr( ISNUM( 1 ) ? hb_parni( 1 ) : -2 ) ); + hb_retni( hb_ctwSetShadowAttr( ISNUM( 1 ) ? hb_parni( 1 ) : -2 ) ); } HB_FUNC( WSETMOVE ) { - hb_retl( hb_ctw_SetMoveMode( ISLOG( 1 ) ? hb_parl( 1 ) : -1 ) != 0 ); + hb_retl( hb_ctwSetMoveMode( ISLOG( 1 ) ? hb_parl( 1 ) : -1 ) != 0 ); } HB_FUNC( WSTEP ) { if( ISNUM( 1 ) && ISNUM( 2 ) ) - hb_retni( hb_ctw_SetMoveStep( hb_parni( 1 ), hb_parni( 2 ) ) ); + hb_retni( hb_ctwSetMoveStep( hb_parni( 1 ), hb_parni( 2 ) ) ); else hb_retni( -1 ); } HB_FUNC( WMODE ) { - hb_retni( hb_ctw_SetBorderMode( ISLOG( 1 ) ? ( hb_parl( 1 ) ? 1 : 0 ) : -1, - ISLOG( 2 ) ? ( hb_parl( 2 ) ? 1 : 0 ) : -1, - ISLOG( 3 ) ? ( hb_parl( 3 ) ? 1 : 0 ) : -1, - ISLOG( 4 ) ? ( hb_parl( 4 ) ? 1 : 0 ) : -1 ) ); + hb_retni( hb_ctwSetBorderMode( ISLOG( 1 ) ? ( hb_parl( 1 ) ? 1 : 0 ) : -1, + ISLOG( 2 ) ? ( hb_parl( 2 ) ? 1 : 0 ) : -1, + ISLOG( 3 ) ? ( hb_parl( 3 ) ? 1 : 0 ) : -1, + ISLOG( 4 ) ? ( hb_parl( 4 ) ? 1 : 0 ) : -1 ) ); } HB_FUNC( WBOARD ) { - int iResult; - - iResult = hb_ctw_SetWindowBoard( hb_parni( 1 ), hb_parni( 2 ), - ISNUM( 3 ) ? hb_parni( 3 ) : hb_gtMaxRow(), - ISNUM( 4 ) ? hb_parni( 4 ) : hb_gtMaxCol() ); - hb_gtFlush(); - hb_retni( iResult ); + hb_retni( hb_ctwSetWindowBoard( hb_parni( 1 ), hb_parni( 2 ), + ISNUM( 3 ) ? hb_parni( 3 ) : hb_gtMaxRow(), + ISNUM( 4 ) ? hb_parni( 4 ) : hb_gtMaxCol() ) ); } HB_FUNC( WOPEN ) { - int iResult, iColor; + int iColor; iColor = ISCHAR( 6 ) ? hb_gtColorToN( hb_parc( 6 ) ) : hb_parni( 6 ); - iResult = hb_ctw_CreateWindow( hb_parni( 1 ), hb_parni( 2 ), - hb_parni( 3 ), hb_parni( 4 ), - hb_parl( 5 ), iColor ); - hb_gtFlush(); - hb_retni( iResult ); + hb_retni( hb_ctwCreateWindow( hb_parni( 1 ), hb_parni( 2 ), + hb_parni( 3 ), hb_parni( 4 ), + hb_parl( 5 ), iColor ) ); } HB_FUNC( WCLOSE ) { - int iResult; - - iResult = hb_ctw_CloseWindow( hb_ctw_CurrentWindow() ); - hb_gtFlush(); - hb_retni( iResult ); + hb_retni( hb_ctwCloseWindow( hb_ctwCurrentWindow() ) ); } HB_FUNC( WACLOSE ) { - int iResult; - - iResult = hb_ctw_CloseAllWindows(); - hb_gtFlush(); - hb_retni( iResult ); + hb_retni( hb_ctwCloseAllWindows() ); } HB_FUNC( WSELECT ) { - int iResult; - - if( ISNUM( 1 ) ) - iResult = hb_ctw_SelectWindow( hb_parni( 1 ) ); - else - iResult = hb_ctw_CurrentWindow(); - hb_gtFlush(); - hb_retni( iResult ); + hb_retni( ISNUM( 1 ) ? hb_ctwSelectWindow( hb_parni( 1 ) ) : + hb_ctwCurrentWindow() ); } HB_FUNC( WNUM ) { - hb_retni( hb_ctw_MaxWindow() ); + hb_retni( hb_ctwMaxWindow() ); } HB_FUNC( WBOX ) @@ -203,7 +183,7 @@ HB_FUNC( WBOX ) "лллллллл" }; /* 15 WB_FULL */ BYTE * szBox, szBoxBuf[ 10 ]; - int iResult, iColor; + int iColor; if( ISCHAR( 1 ) ) { @@ -225,23 +205,21 @@ HB_FUNC( WBOX ) } iColor = ISCHAR( 2 ) ? hb_gtColorToN( hb_parc( 2 ) ) : hb_parni( 2 ); - iResult = hb_ctw_AddWindowBox( hb_ctw_CurrentWindow(), szBox, iColor ); - hb_gtFlush(); - hb_retni( iResult ); + hb_retni( hb_ctwAddWindowBox( hb_ctwCurrentWindow(), szBox, iColor ) ); } HB_FUNC( WFORMAT ) { - hb_retni( hb_ctw_ChangeMargins( hb_ctw_CurrentWindow(), - hb_parni( 1 ), hb_parni( 2 ), - hb_parni( 3 ), hb_parni( 4 ) ) ); + hb_retni( hb_ctwChangeMargins( hb_ctwCurrentWindow(), + hb_parni( 1 ), hb_parni( 2 ), + hb_parni( 3 ), hb_parni( 4 ) ) ); } HB_FUNC( WROW ) { int iTop, iLeft, iBottom, iRight; - hb_ctw_GetWindowCords( hb_ctw_CurrentWindow(), hb_parl( 1 ), &iTop, &iLeft, &iBottom, &iRight ); + hb_ctwGetWindowCords( hb_ctwCurrentWindow(), hb_parl( 1 ), &iTop, &iLeft, &iBottom, &iRight ); hb_retni( iTop ); } @@ -249,7 +227,7 @@ HB_FUNC( WCOL ) { int iTop, iLeft, iBottom, iRight; - hb_ctw_GetWindowCords( hb_ctw_CurrentWindow(), hb_parl( 1 ), &iTop, &iLeft, &iBottom, &iRight ); + hb_ctwGetWindowCords( hb_ctwCurrentWindow(), hb_parl( 1 ), &iTop, &iLeft, &iBottom, &iRight ); hb_retni( iLeft ); } @@ -257,7 +235,7 @@ HB_FUNC( WLASTROW ) { int iTop, iLeft, iBottom, iRight; - hb_ctw_GetWindowCords( hb_ctw_CurrentWindow(), hb_parl( 1 ), &iTop, &iLeft, &iBottom, &iRight ); + hb_ctwGetWindowCords( hb_ctwCurrentWindow(), hb_parl( 1 ), &iTop, &iLeft, &iBottom, &iRight ); hb_retni( iBottom ); } @@ -265,7 +243,7 @@ HB_FUNC( WLASTCOL ) { int iTop, iLeft, iBottom, iRight; - hb_ctw_GetWindowCords( hb_ctw_CurrentWindow(), hb_parl( 1 ), &iTop, &iLeft, &iBottom, &iRight ); + hb_ctwGetWindowCords( hb_ctwCurrentWindow(), hb_parl( 1 ), &iTop, &iLeft, &iBottom, &iRight ); hb_retni( iRight ); } @@ -273,7 +251,7 @@ HB_FUNC( WFROW ) { int iTop, iLeft, iBottom, iRight; - hb_ctw_GetFormatCords( hb_ctw_CurrentWindow(), hb_parl( 1 ), &iTop, &iLeft, &iBottom, &iRight ); + hb_ctwGetFormatCords( hb_ctwCurrentWindow(), hb_parl( 1 ), &iTop, &iLeft, &iBottom, &iRight ); hb_retni( iTop ); } @@ -281,7 +259,7 @@ HB_FUNC( WFCOL ) { int iTop, iLeft, iBottom, iRight; - hb_ctw_GetFormatCords( hb_ctw_CurrentWindow(), hb_parl( 1 ), &iTop, &iLeft, &iBottom, &iRight ); + hb_ctwGetFormatCords( hb_ctwCurrentWindow(), hb_parl( 1 ), &iTop, &iLeft, &iBottom, &iRight ); hb_retni( iLeft ); } @@ -289,7 +267,7 @@ HB_FUNC( WFLASTROW ) { int iTop, iLeft, iBottom, iRight; - hb_ctw_GetFormatCords( hb_ctw_CurrentWindow(), hb_parl( 1 ), &iTop, &iLeft, &iBottom, &iRight ); + hb_ctwGetFormatCords( hb_ctwCurrentWindow(), hb_parl( 1 ), &iTop, &iLeft, &iBottom, &iRight ); hb_retni( iBottom ); } @@ -297,17 +275,17 @@ HB_FUNC( WFLASTCOL ) { int iTop, iLeft, iBottom, iRight; - hb_ctw_GetFormatCords( hb_ctw_CurrentWindow(), hb_parl( 1 ), &iTop, &iLeft, &iBottom, &iRight ); + hb_ctwGetFormatCords( hb_ctwCurrentWindow(), hb_parl( 1 ), &iTop, &iLeft, &iBottom, &iRight ); hb_retni( iRight ); } HB_FUNC( WCENTER ) { - hb_retni( hb_ctw_CenterWindow( hb_ctw_CurrentWindow(), hb_parl( 1 ) ) ); + hb_retni( hb_ctwCenterWindow( hb_ctwCurrentWindow(), hb_parl( 1 ) ) ); } HB_FUNC( WMOVE ) { - hb_retni( hb_ctw_MoveWindow( hb_ctw_CurrentWindow(), - hb_parni( 1 ), hb_parni( 2 ) ) ); + hb_retni( hb_ctwMoveWindow( hb_ctwCurrentWindow(), + hb_parni( 1 ), hb_parni( 2 ) ) ); } diff --git a/harbour/contrib/hbct/ctwin.c b/harbour/contrib/hbct/ctwin.c index aff5da9422..f875fdd627 100644 --- a/harbour/contrib/hbct/ctwin.c +++ b/harbour/contrib/hbct/ctwin.c @@ -143,12 +143,14 @@ static int hb_ctw_CalcShadowWidth( int iRows, int iCols ) return 2; } -static void hb_ctw_SetMap( int * piMap, int iWindow, int iTop, int iLeft, int iBottom, int iRight ) +static void hb_ctw_SetMap( PHB_GT pGT, int * piMap, int iWindow, int iTop, int iLeft, int iBottom, int iRight ) { ULONG lIndex; int i; - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_SetMap(%p,%d,%d,%d,%d,%d)", piMap, iWindow, iTop, iLeft, iBottom, iRight)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_SetMap(%p,%p,%d,%d,%d,%d,%d)", pGT, piMap, iWindow, iTop, iLeft, iBottom, iRight)); + + HB_SYMBOL_UNUSED( pGT ); if( iTop < 0 ) iTop = 0; @@ -168,22 +170,24 @@ static void hb_ctw_SetMap( int * piMap, int iWindow, int iTop, int iLeft, int iB } } -static void hb_ctw_ClearMap( void ) +static void hb_ctw_ClearMap( PHB_GT pGT ) { ULONG ulSize; - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_ClearMap()")); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_ClearMap(%p)", pGT)); + + HB_SYMBOL_UNUSED( pGT ); ulSize = ( ULONG ) s_iMapHeight * s_iMapWidth * sizeof( int ); memset( s_pWindowMap, 0, ulSize ); memset( s_pShadowMap, 0, ulSize ); } -static void hb_ctw_WindowMap( int iWindow, BOOL fExpose ) +static void hb_ctw_WindowMap( PHB_GT pGT, int iWindow, BOOL fExpose ) { PHB_CT_WND pWnd; - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_WindowMap(%d,%d)", iWindow, (int) fExpose)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_WindowMap(%p,%d,%d)", pGT, iWindow, (int) fExpose)); pWnd = s_windows[ iWindow ]; @@ -192,10 +196,10 @@ static void hb_ctw_WindowMap( int iWindow, BOOL fExpose ) int iLastRow = pWnd->iFirstRow + pWnd->iHeight - 1, iLastCol = pWnd->iFirstCol + pWnd->iWidth - 1; - hb_ctw_SetMap( s_pWindowMap, iWindow, + hb_ctw_SetMap( pGT, s_pWindowMap, iWindow, pWnd->iFirstRow, pWnd->iFirstCol, iLastRow, iLastCol ); - hb_ctw_SetMap( s_pShadowMap, 0, + hb_ctw_SetMap( pGT, s_pShadowMap, 0, pWnd->iFirstRow, pWnd->iFirstCol, iLastRow, iLastCol ); if( pWnd->iShadowAttr >= 0 && @@ -204,39 +208,39 @@ static void hb_ctw_WindowMap( int iWindow, BOOL fExpose ) { iLastRow += 1; iLastCol += s_iShadowWidth; - hb_ctw_SetMap( s_pShadowMap, iWindow, + hb_ctw_SetMap( pGT, s_pShadowMap, iWindow, iLastRow, pWnd->iFirstCol + s_iShadowWidth, iLastRow, iLastCol ); - hb_ctw_SetMap( s_pShadowMap, iWindow, + hb_ctw_SetMap( pGT, s_pShadowMap, iWindow, pWnd->iFirstRow + 1, pWnd->iFirstCol + pWnd->iWidth, iLastRow - 1, iLastCol ); } if( fExpose ) { - HB_GTSUPER_EXPOSEAREA( pWnd->iFirstRow, pWnd->iFirstCol, - iLastRow, iLastCol ); + HB_GTSUPER_EXPOSEAREA( pGT, pWnd->iFirstRow, pWnd->iFirstCol, + iLastRow, iLastCol ); } } } -static void hb_ctw_RemapAllWindows( void ) +static void hb_ctw_RemapAllWindows( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_RemapAllWindows()")); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_RemapAllWindows(%p)", pGT)); if( s_iMaxWindow ) { int i; - hb_ctw_ClearMap(); + hb_ctw_ClearMap( pGT ); for( i = 0; i < s_iOpenWindows; ++i ) - hb_ctw_WindowMap( s_windowStack[ i ], FALSE ); - HB_GTSUPER_EXPOSEAREA( 0, 0, s_iMapHeight, s_iMapWidth ); + hb_ctw_WindowMap( pGT, s_windowStack[ i ], FALSE ); + HB_GTSUPER_EXPOSEAREA( pGT, 0, 0, s_iMapHeight, s_iMapWidth ); } } -BOOL hb_ctw_Init( void ) +static BOOL hb_ctw_Init( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_Init()")); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_Init(%p)",pGT)); if( ! s_fInit ) { @@ -245,22 +249,24 @@ BOOL hb_ctw_Init( void ) { int iRow, iCol; - HB_GTSUPER_GETSIZE( &s_iMapHeight, &s_iMapWidth ); + HB_GTSUPER_GETSIZE( pGT, &s_iMapHeight, &s_iMapWidth ); /* update cursor position to the rules used by CTWIN */ - hb_gt_GetPos( &iRow, &iCol ); - hb_gt_SetPos( iRow, iCol ); + HB_GTSELF_GETPOS( pGT, &iRow, &iCol ); + HB_GTSELF_SETPOS( pGT, iRow, iCol ); } } return s_fInit; } -int hb_ctw_SetShadowAttr( int iAttr ) +static int hb_ctw_SetShadowAttr( PHB_GT pGT, int iAttr ) { int iOldAttr = s_iShadowAttr; - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_SetShadowAttr(%d)", iAttr)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_SetShadowAttr(%p,%d)", pGT, iAttr)); + + HB_SYMBOL_UNUSED( pGT ); if( iAttr >= -1 ) s_iShadowAttr = iAttr; @@ -268,11 +274,13 @@ int hb_ctw_SetShadowAttr( int iAttr ) return iOldAttr; } -int hb_ctw_SetMoveMode( int iMode ) +static int hb_ctw_SetMoveMode( PHB_GT pGT, int iMode ) { int iOldMode = s_iMoveMode; - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_SetMoveMode(%d)", iMode)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_SetMoveMode(%p,%d)", pGT, iMode)); + + HB_SYMBOL_UNUSED( pGT ); if( iMode >= 0 ) s_iMoveMode = iMode; @@ -280,11 +288,11 @@ int hb_ctw_SetMoveMode( int iMode ) return iOldMode; } -int hb_ctw_SetMoveStep( int iVertical, int iHorizontal ) +static int hb_ctw_SetMoveStep( PHB_GT pGT, int iVertical, int iHorizontal ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_SetMoveStep(%d,%d)", iVertical, iHorizontal)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_SetMoveStep(%p,%d,%d)", pGT, iVertical, iHorizontal)); - if( s_fInit || hb_ctw_Init() ) + if( s_fInit || hb_ctw_Init( pGT ) ) { if( iVertical < s_iMapHeight && iHorizontal < s_iMapWidth ) { @@ -298,11 +306,11 @@ int hb_ctw_SetMoveStep( int iVertical, int iHorizontal ) return -1; } -int hb_ctw_SetWindowBoard( int iTop, int iLeft, int iBottom, int iRight ) +static int hb_ctw_SetWindowBoard( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_SetWindowBoard(%d,%d,%d,%d)", iTop, iLeft, iBottom, iRight)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_SetWindowBoard(%d,%d,%d,%d)", iTop, iLeft, iBottom, iRight)); - if( s_fInit || hb_ctw_Init() ) + if( s_fInit || hb_ctw_Init( pGT ) ) { /* * This limitation is only for strict CT3 compatibility, the CTW GTs @@ -320,7 +328,7 @@ int hb_ctw_SetWindowBoard( int iTop, int iLeft, int iBottom, int iRight ) s_iBoardBottom = iBottom; s_iBoardRight = iRight; s_fBoardSet = TRUE; - hb_ctw_RemapAllWindows(); + hb_ctw_RemapAllWindows( pGT ); return 0; } @@ -329,11 +337,11 @@ int hb_ctw_SetWindowBoard( int iTop, int iLeft, int iBottom, int iRight ) return -1; } -int hb_ctw_SetBorderMode( int iTop, int iLeft, int iBottom, int iRight ) +static int hb_ctw_SetBorderMode( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_SetBorderMode(%d,%d,%d,%d)", iTop, iLeft, iBottom, iRight)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_SetBorderMode(%p,%d,%d,%d,%d)", pGT, iTop, iLeft, iBottom, iRight)); - if( s_fInit || hb_ctw_Init() ) + if( s_fInit || hb_ctw_Init( pGT ) ) { if( iTop >= 0 ) s_fBoardTop = iTop != 0; @@ -350,16 +358,18 @@ int hb_ctw_SetBorderMode( int iTop, int iLeft, int iBottom, int iRight ) return -1; } -int hb_ctw_CurrentWindow( void ) +static int hb_ctw_CurrentWindow( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_CurrentWindow()")); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_CurrentWindow(%p)", pGT)); + + HB_SYMBOL_UNUSED( pGT ); return s_iCurrWindow; } -int hb_ctw_SelectWindow( int iWindow ) +static int hb_ctw_SelectWindow( PHB_GT pGT, int iWindow ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_SelectWindow(%d)", iWindow)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_SelectWindow(%p,%d)", pGT, iWindow)); if( iWindow == 0 ) s_iCurrWindow = iWindow; @@ -384,18 +394,20 @@ int hb_ctw_SelectWindow( int iWindow ) } s_windowStack[ s_iOpenWindows - 1 ] = iWindow; /* INFO: CT effectively calls hb_ctw_RemapAllWindows() here */ - hb_ctw_WindowMap( iWindow, TRUE ); + hb_ctw_WindowMap( pGT, iWindow, TRUE ); } } return s_iCurrWindow; } -int hb_ctw_MaxWindow( void ) +static int hb_ctw_MaxWindow( PHB_GT pGT ) { int i, iMaxHandle = 0; - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_MaxWindow()")); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_MaxWindow(%p)", pGT)); + + HB_SYMBOL_UNUSED( pGT ); for( i = 0; i < s_iOpenWindows; ++i ) { @@ -406,7 +418,7 @@ int hb_ctw_MaxWindow( void ) return iMaxHandle; } -int hb_ctw_CreateWindow( int iTop, int iLeft, int iBottom, int iRight, BOOL fClear, int iColor ) +static int hb_ctw_CreateWindow( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BOOL fClear, int iColor ) { PHB_CT_WND pWnd; BYTE bAttr, bColor; @@ -414,7 +426,7 @@ int hb_ctw_CreateWindow( int iTop, int iLeft, int iBottom, int iRight, BOOL fCle int iRow, iCol, iHeight, iWidth, iTmp; long lIndex; - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_CreateWindow(%d,%d,%d,%d,%d,%d)", iTop, iLeft, iBottom, iRight, (int) fClear, iColor)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_CreateWindow(%p,%d,%d,%d,%d,%d,%d)", pGT, iTop, iLeft, iBottom, iRight, (int) fClear, iColor)); if( s_iOpenWindows == s_iMaxWindow ) { @@ -426,18 +438,18 @@ int hb_ctw_CreateWindow( int iTop, int iLeft, int iBottom, int iRight, BOOL fCle if( !s_fInit ) { - if( ! hb_ctw_Init() ) + if( ! hb_ctw_Init( pGT ) ) return -1; } - HB_GTSUPER_GETSIZE( &s_iMapHeight, &s_iMapWidth ); + HB_GTSUPER_GETSIZE( pGT, &s_iMapHeight, &s_iMapWidth ); s_iShadowWidth = hb_ctw_CalcShadowWidth( s_iMapHeight, s_iMapWidth ); if( !s_fBoardSet ) - hb_ctw_SetWindowBoard( 0, 0, s_iMapHeight - 1, s_iMapWidth - 1 ); + hb_ctw_SetWindowBoard( pGT, 0, 0, s_iMapHeight - 1, s_iMapWidth - 1 ); ulSize = ( ULONG ) s_iMapHeight * s_iMapWidth * sizeof( int ); s_pWindowMap = ( int * ) hb_xgrab( ulSize ); s_pShadowMap = ( int * ) hb_xgrab( ulSize ); - hb_ctw_ClearMap(); + hb_ctw_ClearMap( pGT ); s_iMaxWindow = HB_CTWIN_ALLOC; s_windows = ( PHB_CT_WND * ) hb_xgrab( ( HB_CTWIN_ALLOC + 1 ) * sizeof( PHB_CT_WND ) ); @@ -491,14 +503,14 @@ int hb_ctw_CreateWindow( int iTop, int iLeft, int iBottom, int iRight, BOOL fCle pWnd->fHidden = FALSE; pWnd->iShadowAttr = s_iShadowAttr; - pWnd->iCursorStyle = hb_gt_GetCursorStyle(); + pWnd->iCursorStyle = HB_GTSELF_GETCURSORSTYLE( pGT ); pWnd->iHeight = iHeight; pWnd->iWidth = iWidth; pWnd->iFirstRow = iRow; pWnd->iFirstCol = iCol; - hb_gt_GetColorData( &pWnd->piColors, &pWnd->iColorCount, &pWnd->iColorIndex ); + HB_GTSELF_GETCOLORDATA( pGT, &pWnd->piColors, &pWnd->iColorCount, &pWnd->iColorIndex ); pWnd->screenBuffer = ( PHB_SCREENCELL ) hb_xgrab( ( ULONG ) pWnd->iHeight * pWnd->iWidth * sizeof( HB_SCREENCELL ) ); @@ -506,18 +518,18 @@ int hb_ctw_CreateWindow( int iTop, int iLeft, int iBottom, int iRight, BOOL fCle if( pWnd->iShadowAttr >= 0 ) fClear = TRUE; bAttr = 0; - bColor = iColor ? iColor : hb_gt_GetColor(); - usChar = ( USHORT ) hb_gt_GetClearChar(); + bColor = iColor ? iColor : HB_GTSELF_GETCOLOR( pGT ); + usChar = ( USHORT ) HB_GTSELF_GETCLEARCHAR( pGT ); lIndex = 0; for( iRow = pWnd->iFirstRow; iRow < pWnd->iFirstRow + pWnd->iHeight; ++iRow ) { for( iCol = pWnd->iFirstCol; iCol < pWnd->iFirstCol + pWnd->iWidth; ++iCol ) { - if( !fClear && !hb_gt_GetScrChar( iRow, iCol, &bColor, &bAttr, &usChar ) ) + if( !fClear && !HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol, &bColor, &bAttr, &usChar ) ) { - usChar = ( USHORT ) hb_gt_GetClearChar(); - bColor = ( BYTE ) hb_gt_GetColor(); + usChar = ( USHORT ) HB_GTSELF_GETCLEARCHAR( pGT ); + bColor = ( BYTE ) HB_GTSELF_GETCOLOR( pGT ); bAttr = 0; } pWnd->screenBuffer[ lIndex ].c.usChar = usChar; @@ -538,14 +550,14 @@ int hb_ctw_CreateWindow( int iTop, int iLeft, int iBottom, int iRight, BOOL fCle s_windowStack[ s_iOpenWindows++ ] = pWnd->iHandle; s_iCurrWindow = pWnd->iHandle; - hb_ctw_WindowMap( pWnd->iHandle, TRUE ); + hb_ctw_WindowMap( pGT, pWnd->iHandle, TRUE ); return pWnd->iHandle; } -int hb_ctw_CloseWindow( int iWindow ) +static int hb_ctw_CloseWindow( PHB_GT pGT, int iWindow ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_CloseWindow(%d)", iWindow)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_CloseWindow(%p,%d)", pGT, iWindow)); if( iWindow > 0 && iWindow <= s_iMaxWindow && s_windows[ iWindow ] ) { @@ -575,16 +587,16 @@ int hb_ctw_CloseWindow( int iWindow ) s_iCurrWindow = s_iOpenWindows > 0 ? s_windowStack[ s_iOpenWindows - 1 ] : 0; if( !fHidden ) - hb_ctw_RemapAllWindows(); + hb_ctw_RemapAllWindows( pGT ); return s_iCurrWindow; } return -1; } -int hb_ctw_CloseAllWindows( void ) +static int hb_ctw_CloseAllWindows( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_CloseAllWindows()")); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_CloseAllWindows(%p)", pGT)); if( s_iOpenWindows > 0 ) { @@ -603,16 +615,18 @@ int hb_ctw_CloseAllWindows( void ) hb_xfree( pWnd ); } s_iOpenWindows = s_iCurrWindow = 0; - hb_ctw_RemapAllWindows(); + hb_ctw_RemapAllWindows( pGT ); return 0; } return -1; } -int hb_ctw_CenterWindow( int iWindow, BOOL fCenter ) +static int hb_ctw_CenterWindow( PHB_GT pGT, int iWindow, BOOL fCenter ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_CenterWindow(%d,%d)", iWindow, (int) fCenter)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_CenterWindow(%p,%d,%d)", pGT, iWindow, (int) fCenter)); + + HB_SYMBOL_UNUSED( pGT ); if( iWindow > 0 && iWindow <= s_iOpenWindows ) { @@ -651,9 +665,9 @@ int hb_ctw_CenterWindow( int iWindow, BOOL fCenter ) return -1; } -int hb_ctw_MoveWindow( int iWindow, int iRow, int iCol ) +static int hb_ctw_MoveWindow( PHB_GT pGT, int iWindow, int iRow, int iCol ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_MoveWindow(%d,%d,%d)", iWindow, iRow, iCol)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_MoveWindow(%p,%d,%d,%d)", pGT, iWindow, iRow, iCol)); if( iWindow > 0 && iWindow <= s_iOpenWindows ) { @@ -669,7 +683,7 @@ int hb_ctw_MoveWindow( int iWindow, int iRow, int iCol ) pWnd->iFirstRow = iRow; pWnd->iFirstCol = iCol; if( ! pWnd->fHidden ) - hb_ctw_RemapAllWindows(); + hb_ctw_RemapAllWindows( pGT ); return iWindow; } } @@ -678,9 +692,11 @@ int hb_ctw_MoveWindow( int iWindow, int iRow, int iCol ) return -1; } -int hb_ctw_ChangeMargins( int iWindow, int iTop, int iLeft, int iBottom, int iRight ) +static int hb_ctw_ChangeMargins( PHB_GT pGT, int iWindow, int iTop, int iLeft, int iBottom, int iRight ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_ChangeMargins(%d,%d,%d,%d,%d)", iWindow, iTop, iLeft, iBottom, iRight)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_ChangeMargins(%p,%d,%d,%d,%d,%d)", pGT, iWindow, iTop, iLeft, iBottom, iRight)); + + HB_SYMBOL_UNUSED( pGT ); if( iWindow > 0 && iWindow <= s_iOpenWindows ) { @@ -712,9 +728,9 @@ int hb_ctw_ChangeMargins( int iWindow, int iTop, int iLeft, int iBottom, int iRi return -1; } -int hb_ctw_GetWindowCords( int iWindow, BOOL fCenter, int * piTop, int * piLeft, int * piBottom, int * piRight ) +static int hb_ctw_GetWindowCords( PHB_GT pGT, int iWindow, BOOL fCenter, int * piTop, int * piLeft, int * piBottom, int * piRight ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_GetWindowCords(%d,%d,%p,%p,%p,%p)", iWindow, (int) fCenter, piTop, piLeft, piBottom, piRight)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_GetWindowCords(%p,%d,%d,%p,%p,%p,%p)", pGT, iWindow, (int) fCenter, piTop, piLeft, piBottom, piRight)); if( iWindow > 0 && iWindow <= s_iOpenWindows ) { @@ -748,15 +764,15 @@ int hb_ctw_GetWindowCords( int iWindow, BOOL fCenter, int * piTop, int * piLeft, } *piTop = *piLeft = 0; - *piBottom = hb_gt_MaxRow(); - *piRight = hb_gt_MaxCol(); + *piBottom = HB_GTSELF_MAXROW( pGT ); + *piRight = HB_GTSELF_MAXCOL( pGT ); return -1; } -int hb_ctw_GetFormatCords( int iWindow, BOOL fRelative, int * piTop, int * piLeft, int * piBottom, int * piRight ) +static int hb_ctw_GetFormatCords( PHB_GT pGT, int iWindow, BOOL fRelative, int * piTop, int * piLeft, int * piBottom, int * piRight ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_GetFormatCords(%d,%d,%p,%p,%p,%p)", iWindow, (int) fRelative, piTop, piLeft, piBottom, piRight)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_GetFormatCords(%p,%d,%d,%p,%p,%p,%p)", pGT, iWindow, (int) fRelative, piTop, piLeft, piBottom, piRight)); if( iWindow > 0 && iWindow <= s_iOpenWindows ) { @@ -789,8 +805,8 @@ int hb_ctw_GetFormatCords( int iWindow, BOOL fRelative, int * piTop, int * piLef else { *piTop = *piLeft = 0; - *piBottom = hb_gt_MaxRow(); - *piRight = hb_gt_MaxCol(); + *piBottom = HB_GTSELF_MAXROW( pGT ); + *piRight = HB_GTSELF_MAXCOL( pGT ); } return -1; @@ -798,28 +814,28 @@ int hb_ctw_GetFormatCords( int iWindow, BOOL fRelative, int * piTop, int * piLef /* ********************************************************************** */ -int hb_ctw_AddWindowBox( int iWindow, BYTE * szBox, int iColor ) +static int hb_ctw_AddWindowBox( PHB_GT pGT, int iWindow, BYTE * szBox, int iColor ) { int iMaxRow, iMaxCol; - HB_TRACE(HB_TR_DEBUG, ( "hb_ctw_AddWindowBox(%d,%p,%d)", iWindow, szBox, iColor)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_AddWindowBox(%p,%d,%p,%d)", pGT, iWindow, szBox, iColor)); - iMaxRow = hb_gt_MaxRow(); - iMaxCol = hb_gtMaxCol(); + iMaxRow = HB_GTSELF_MAXROW( pGT ); + iMaxCol = HB_GTSELF_MAXCOL( pGT ); if( iMaxRow > 1 && iMaxCol > 1 ) { if( iColor == 0 ) - iColor = hb_gt_GetColor(); - hb_gt_Box( 0, 0, iMaxRow, iMaxCol, szBox, iColor ); + iColor = HB_GTSELF_GETCOLOR( pGT ); + HB_GTSELF_BOX( pGT, 0, 0, iMaxRow, iMaxCol, szBox, iColor ); if( iWindow > 0 && iWindow <= s_iOpenWindows && s_windows[ iWindow ] != NULL ) { - hb_gt_SetPos( 0, 0 ); - hb_ctw_ChangeMargins( iWindow, 1, 1, 1, 1 ); + HB_GTSELF_SETPOS( pGT, 0, 0 ); + hb_ctw_ChangeMargins( pGT, iWindow, 1, 1, 1, 1 ); } else - hb_gt_SetPos( 1, 1 ); + HB_GTSELF_SETPOS( pGT, 1, 1 ); return 0; } @@ -829,22 +845,22 @@ int hb_ctw_AddWindowBox( int iWindow, BYTE * szBox, int iColor ) /* ********************************************************************** */ -static void hb_ctw_gt_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) +static void hb_ctw_gt_Init( PHB_GT pGT, FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) { - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_Init(%p,%p,%p)", hFilenoStdin, hFilenoStdout, hFilenoStderr)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_Init(%p,%p,%p,%p)", pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr)); - HB_GTSUPER_INIT( hFilenoStdin, hFilenoStdout, hFilenoStderr ); + HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr ); s_fInit = TRUE; } -static void hb_ctw_gt_Exit( void ) +static void hb_ctw_gt_Exit( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_Exit()")); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_Exit(%p)", pGT)); if( s_iMaxWindow > 0 ) { - hb_ctw_CloseAllWindows(); + hb_ctw_CloseAllWindows( pGT ); hb_xfree( s_windows ); hb_xfree( s_windowStack ); @@ -858,16 +874,16 @@ static void hb_ctw_gt_Exit( void ) s_fBoardSet = s_fInit = FALSE; } - HB_GTSUPER_EXIT(); + HB_GTSUPER_EXIT( pGT ); } -static int hb_ctw_MouseRow( void ) +static int hb_ctw_MouseRow( PHB_GT pGT ) { int iRow; - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_MouseRow()")); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_MouseRow(%p)", pGT)); - iRow = HB_GTSUPER_MOUSEROW(); + iRow = HB_GTSUPER_MOUSEROW( pGT ); if( s_iCurrWindow > 0 ) iRow -= s_windows[ s_iCurrWindow ]->iFirstRow + @@ -876,13 +892,13 @@ static int hb_ctw_MouseRow( void ) return iRow; } -static int hb_ctw_MouseCol( void ) +static int hb_ctw_MouseCol( PHB_GT pGT ) { int iCol; - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_MouseCol()")); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_MouseCol(%p)", pGT)); - iCol = HB_GTSUPER_MOUSECOL(); + iCol = HB_GTSUPER_MOUSECOL( pGT ); if( s_iCurrWindow > 0 ) iCol -= s_windows[ s_iCurrWindow ]->iFirstCol + @@ -891,9 +907,9 @@ static int hb_ctw_MouseCol( void ) return iCol; } -static void hb_ctw_gt_GetPos( int * piRow, int * piCol ) +static void hb_ctw_gt_GetPos( PHB_GT pGT, int * piRow, int * piCol ) { - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetPos(%p,%p)", piRow, piCol)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetPos(%p,%p,%p)", pGT, piRow, piCol)); if( s_iCurrWindow > 0 ) { @@ -901,7 +917,7 @@ static void hb_ctw_gt_GetPos( int * piRow, int * piCol ) *piCol = s_windows[ s_iCurrWindow ]->iCol; } else - HB_GTSUPER_GETPOS( piRow, piCol ); + HB_GTSUPER_GETPOS( pGT, piRow, piCol ); } /* @@ -909,14 +925,14 @@ static void hb_ctw_gt_GetPos( int * piRow, int * piCol ) * area then standard Clipper's GT drivers so we have to replicate it in * SETPOS() method, [druzus] */ -static void hb_ctw_gt_SetPos( int iRow, int iCol ) +static void hb_ctw_gt_SetPos( PHB_GT pGT, int iRow, int iCol ) { int iHeight, iWidth; - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetPos(%d,%d)", iRow, iCol)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetPos(%p,%d,%d)", pGT, iRow, iCol)); - iHeight = hb_gt_MaxRow() + 1; - iWidth = hb_gt_MaxCol() + 1; + iHeight = HB_GTSELF_MAXROW( pGT ) + 1; + iWidth = HB_GTSELF_MAXCOL( pGT ) + 1; if( iCol > iWidth ) iCol = iWidth; @@ -939,32 +955,32 @@ static void hb_ctw_gt_SetPos( int iRow, int iCol ) { if( iRow < 0 ) iRow = 0; - HB_GTSUPER_SETPOS( iRow, iCol ); + HB_GTSUPER_SETPOS( pGT, iRow, iCol ); } } -static int hb_ctw_gt_MaxCol( void ) +static int hb_ctw_gt_MaxCol( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_MaxCol()")); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_MaxCol(%p)", pGT)); if( s_iCurrWindow > 0 ) return s_windows[ s_iCurrWindow ]->iWidth - s_windows[ s_iCurrWindow ]->iLeftMargin - s_windows[ s_iCurrWindow ]->iRightMargin - 1; else - return HB_GTSUPER_MAXCOL(); + return HB_GTSUPER_MAXCOL( pGT ); } -static int hb_ctw_gt_MaxRow( void ) +static int hb_ctw_gt_MaxRow( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_MaxRow()")); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_MaxRow(%p)", pGT)); if( s_iCurrWindow > 0 ) return s_windows[ s_iCurrWindow ]->iHeight - s_windows[ s_iCurrWindow ]->iTopMargin - s_windows[ s_iCurrWindow ]->iBottomMargin - 1; else - return HB_GTSUPER_MAXROW(); + return HB_GTSUPER_MAXROW( pGT ); } /* @@ -973,7 +989,7 @@ static int hb_ctw_gt_MaxRow( void ) */ #define WRITECON_BUFFER_SIZE 512 -static void hb_ctw_gt_WriteCon( BYTE * pText, ULONG ulLength ) +static void hb_ctw_gt_WriteCon( PHB_GT pGT, BYTE * pText, ULONG ulLength ) { int iLen = 0; BOOL bDisp = FALSE; @@ -981,12 +997,12 @@ static void hb_ctw_gt_WriteCon( BYTE * pText, ULONG ulLength ) int iRow, iCol, iMaxRow, iMaxCol; BYTE szString[ WRITECON_BUFFER_SIZE ]; - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_WriteCon(%p,%lu)", pText, ulLength)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_WriteCon(%p,%p,%lu)", pGT, pText, ulLength)); - iMaxRow = hb_gt_MaxRow(); - iMaxCol = hb_gt_MaxCol(); + iMaxRow = HB_GTSELF_MAXROW( pGT ); + iMaxCol = HB_GTSELF_MAXCOL( pGT ); - hb_gt_GetPos( &iRow, &iCol ); + HB_GTSELF_GETPOS( pGT, &iRow, &iCol ); if( iRow > iMaxRow || iCol > iMaxCol ) { @@ -994,7 +1010,7 @@ static void hb_ctw_gt_WriteCon( BYTE * pText, ULONG ulLength ) iRow = iMaxRow; if( iCol > iMaxCol ) iCol = iMaxCol; - hb_gt_SetPos( iRow, iCol ); + HB_GTSELF_SETPOS( pGT, iRow, iCol ); } while( ulLength-- ) @@ -1025,7 +1041,7 @@ static void hb_ctw_gt_WriteCon( BYTE * pText, ULONG ulLength ) szString[ iLen - 1 ] = ' '; else { - hb_gt_SetPos( iRow, iCol ); + HB_GTSELF_SETPOS( pGT, iRow, iCol ); szString[ iLen++ ] = ' '; } } @@ -1063,24 +1079,27 @@ static void hb_ctw_gt_WriteCon( BYTE * pText, ULONG ulLength ) if( bDisp || ulLength == 0 ) { if( iLen ) - hb_gt_Write( szString, iLen ); + HB_GTSELF_WRITE( pGT, szString, iLen ); iLen = 0; if( iRow > iMaxRow ) { - hb_gt_Scroll( 0, 0, iMaxRow, iMaxCol, ( BYTE ) hb_gt_GetColor(), hb_gt_GetClearChar(), iRow - iMaxRow, 0 ); + HB_GTSELF_SCROLL( pGT, 0, 0, iMaxRow, iMaxCol, + HB_GTSELF_GETCOLOR( pGT ), + HB_GTSELF_GETCLEARCHAR( pGT ), + iRow - iMaxRow, 0 ); iRow = iMaxRow; iCol = 0; } - hb_gt_SetPos( iRow, iCol ); + HB_GTSELF_SETPOS( pGT, iRow, iCol ); bDisp = FALSE; /* To emulate scrolling */ - hb_gt_Flush(); + HB_GTSELF_FLUSH( pGT ); if( bBell ) { - hb_gt_Bell(); + HB_GTSELF_BELL( pGT ); bBell = FALSE; } } @@ -1088,19 +1107,19 @@ static void hb_ctw_gt_WriteCon( BYTE * pText, ULONG ulLength ) } -static int hb_ctw_gt_GetCursorStyle( void ) +static int hb_ctw_gt_GetCursorStyle( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetCursorStyle()")); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetCursorStyle(%p)", pGT)); if( s_iCurrWindow > 0 ) return s_windows[ s_iCurrWindow ]->iCursorStyle; else - return HB_GTSUPER_GETCURSORSTYLE(); + return HB_GTSUPER_GETCURSORSTYLE( pGT ); } -static void hb_ctw_gt_SetCursorStyle( int iStyle ) +static void hb_ctw_gt_SetCursorStyle( PHB_GT pGT, int iStyle ) { - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_SetCursorStyle(%d)", iStyle)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_SetCursorStyle(%p,%d)", pGT, iStyle)); if( s_iCurrWindow > 0 ) { @@ -1119,39 +1138,39 @@ static void hb_ctw_gt_SetCursorStyle( int iStyle ) } } else - HB_GTSUPER_SETCURSORSTYLE( iStyle ); + HB_GTSUPER_SETCURSORSTYLE( pGT, iStyle ); } -static void hb_ctw_gt_GetColorStr( char * pszColorString ) +static void hb_ctw_gt_GetColorStr( PHB_GT pGT, char * pszColorString ) { - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetColorStr(%p)", pszColorString)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetColorStr(%p,%p)", pGT, pszColorString)); if( s_iCurrWindow > 0 ) { PHB_CT_WND pWnd = s_windows[ s_iCurrWindow ]; - HB_GTSUPER_COLORSTOSTRING( pWnd->piColors, pWnd->iColorCount, pszColorString, CLR_STRLEN ); + HB_GTSUPER_COLORSTOSTRING( pGT, pWnd->piColors, pWnd->iColorCount, pszColorString, CLR_STRLEN ); } else - HB_GTSUPER_GETCOLORSTR( pszColorString ); + HB_GTSUPER_GETCOLORSTR( pGT, pszColorString ); } -static void hb_ctw_gt_SetColorStr( const char * szColorString ) +static void hb_ctw_gt_SetColorStr( PHB_GT pGT, const char * szColorString ) { - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_SetColorStr(%s)", szColorString)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_SetColorStr(%p,%s)", pGT, szColorString)); if( s_iCurrWindow > 0 ) { PHB_CT_WND pWnd = s_windows[ s_iCurrWindow ]; - HB_GTSUPER_STRINGTOCOLORS( szColorString, &pWnd->piColors, &pWnd->iColorCount ); + HB_GTSUPER_STRINGTOCOLORS( pGT, szColorString, &pWnd->piColors, &pWnd->iColorCount ); pWnd->iColorIndex = HB_CLR_STANDARD; } else - HB_GTSUPER_SETCOLORSTR( szColorString ); + HB_GTSUPER_SETCOLORSTR( pGT, szColorString ); } -static void hb_ctw_gt_ColorSelect( int iColorIndex ) +static void hb_ctw_gt_ColorSelect( PHB_GT pGT, int iColorIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_ColorSelect(%d)", iColorIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_ColorSelect(%p,%d)", pGT, iColorIndex)); if( s_iCurrWindow > 0 ) { @@ -1160,12 +1179,12 @@ static void hb_ctw_gt_ColorSelect( int iColorIndex ) pWnd->iColorIndex = iColorIndex; } else - HB_GTSUPER_COLORSELECT( iColorIndex ); + HB_GTSUPER_COLORSELECT( pGT, iColorIndex ); } -static int hb_ctw_gt_GetColor( void ) +static int hb_ctw_gt_GetColor( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetColor()")); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetColor(%p)", pGT)); if( s_iCurrWindow > 0 ) { @@ -1173,12 +1192,12 @@ static int hb_ctw_gt_GetColor( void ) return pWnd->piColors[ pWnd->iColorIndex ]; } else - return HB_GTSUPER_GETCOLOR(); + return HB_GTSUPER_GETCOLOR( pGT ); } -static void hb_ctw_gt_GetColorData( int ** pColorsPtr, int * piColorCount, int * piColorIndex ) +static void hb_ctw_gt_GetColorData( PHB_GT pGT, int ** pColorsPtr, int * piColorCount, int * piColorIndex ) { - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetColor(%p,%p,%p)", pColorsPtr, piColorCount, piColorIndex)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetColor(%p,%p,%p,%p)", pGT, pColorsPtr, piColorCount, piColorIndex)); if( s_iCurrWindow > 0 ) { @@ -1190,14 +1209,14 @@ static void hb_ctw_gt_GetColorData( int ** pColorsPtr, int * piColorCount, int * *piColorIndex = pWnd->iColorIndex; } else - HB_GTSUPER_GETCOLORDATA( pColorsPtr, piColorCount, piColorIndex ); + HB_GTSUPER_GETCOLORDATA( pGT, pColorsPtr, piColorCount, piColorIndex ); } -static void hb_ctw_gt_GetScrCursor( int * piRow, int * piCol, int * piStyle ) +static void hb_ctw_gt_GetScrCursor( PHB_GT pGT, int * piRow, int * piCol, int * piStyle ) { - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetScrCursor(%p,%p,%p)", piRow, piCol, piStyle)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetScrCursor(%p,%p,%p,%p)", pGT, piRow, piCol, piStyle)); - HB_GTSUPER_GETSCRCURSOR( piRow, piCol, piStyle ); + HB_GTSUPER_GETSCRCURSOR( pGT, piRow, piCol, piStyle ); if( s_iCurrWindow > 0 ) { *piRow += s_windows[ s_iCurrWindow ]->iFirstRow + @@ -1211,12 +1230,12 @@ static void hb_ctw_gt_GetScrCursor( int * piRow, int * piCol, int * piStyle ) } } -static BOOL hb_ctw_gt_GetScrChar( int iRow, int iCol, +static BOOL hb_ctw_gt_GetScrChar( PHB_GT pGT, int iRow, int iCol, BYTE * pbColor, BYTE * pbAttr, USHORT * pusChar ) { int iWindow = s_iCurrWindow, iShadow = 0; - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetScrChar(%d,%d,%p,%p,%p)", iRow, iCol, pbColor, pbAttr, pusChar)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetScrChar(%p,%d,%d,%p,%p,%p)", pGT, iRow, iCol, pbColor, pbAttr, pusChar)); if( s_iOpenWindows > 0 ) { @@ -1246,7 +1265,7 @@ static BOOL hb_ctw_gt_GetScrChar( int iRow, int iCol, else return FALSE; } - else if( ! HB_GTSUPER_GETSCRCHAR( iRow, iCol, pbColor, pbAttr, pusChar ) ) + else if( ! HB_GTSUPER_GETSCRCHAR( pGT, iRow, iCol, pbColor, pbAttr, pusChar ) ) return FALSE; if( iShadow > 0 ) @@ -1259,14 +1278,14 @@ static BOOL hb_ctw_gt_GetScrChar( int iRow, int iCol, return TRUE; } -static BOOL hb_ctw_gt_GetChar( int iRow, int iCol, +static BOOL hb_ctw_gt_GetChar( PHB_GT pGT, int iRow, int iCol, BYTE * pbColor, BYTE * pbAttr, USHORT * pusChar ) { - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetChar(%d,%d,%p,%p,%p)", iRow, iCol, pbColor, pbAttr, pusChar)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_GetChar(%p,%d,%d,%p,%p,%p)", pGT, iRow, iCol, pbColor, pbAttr, pusChar)); if( s_iCurrWindow == 0 ) /* TODO: it may badly interacts with character translations */ - return hb_gt_GetScrChar( iRow, iCol, pbColor, pbAttr, pusChar ); + return HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol, pbColor, pbAttr, pusChar ); iRow += s_windows[ s_iCurrWindow ]->iTopMargin; iCol += s_windows[ s_iCurrWindow ]->iLeftMargin; @@ -1285,12 +1304,12 @@ static BOOL hb_ctw_gt_GetChar( int iRow, int iCol, return FALSE; } -static BOOL hb_ctw_gt_PutChar( int iRow, int iCol, +static BOOL hb_ctw_gt_PutChar( PHB_GT pGT, int iRow, int iCol, BYTE bColor, BYTE bAttr, USHORT usChar ) { int iWindow = s_iCurrWindow; - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_PutChar(%d,%d,%d,%d,%hu)", iRow, iCol, (int)bColor, (int)bAttr, (int)usChar)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_PutChar(%p,%d,%d,%d,%d,%hu)", pGT, iRow, iCol, (int)bColor, (int)bAttr, (int)usChar)); if( s_iOpenWindows > 0 && iWindow == 0 ) { @@ -1337,24 +1356,24 @@ static BOOL hb_ctw_gt_PutChar( int iRow, int iCol, if( ! s_windows[ iWindow ]->fHidden ) { if( s_iCurrWindow == 0 ) - HB_GTSUPER_TOUCHCELL( iRow, iCol ); + HB_GTSUPER_TOUCHCELL( pGT, iRow, iCol ); else if( iRow >= s_iBoardTop && iRow <= s_iBoardBottom && iCol >= s_iBoardLeft && iCol <= s_iBoardRight ) - HB_GTSUPER_TOUCHCELL( iRow, iCol ); + HB_GTSUPER_TOUCHCELL( pGT, iRow, iCol ); } return TRUE; } return FALSE; } - return HB_GTSUPER_PUTCHAR( iRow, iCol, bColor, bAttr, usChar ); + return HB_GTSUPER_PUTCHAR( pGT, iRow, iCol, bColor, bAttr, usChar ); } -static BOOL hb_ctw_gt_Resize( int iRows, int iCols ) +static BOOL hb_ctw_gt_Resize( PHB_GT pGT, int iRows, int iCols ) { - HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_Resize(%d,%d)", iRows, iCols)); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_Resize(%p,%d,%d)", pGT, iRows, iCols)); - if( HB_GTSUPER_RESIZE( iRows, iCols ) ) + if( HB_GTSUPER_RESIZE( pGT, iRows, iCols ) ) { if( s_iMaxWindow > 0 ) { @@ -1368,15 +1387,15 @@ static BOOL hb_ctw_gt_Resize( int iRows, int iCols ) s_pShadowMap = ( int * ) hb_xrealloc( s_pShadowMap, ulSize ); } if( s_fBoardSet ) - hb_ctw_SetWindowBoard( 0, 0, iRows - 1, iCols - 1 ); + hb_ctw_SetWindowBoard( pGT, 0, 0, iRows - 1, iCols - 1 ); return TRUE; } return FALSE; } -static BOOL hb_ctw_gt_Info( int iType, PHB_GT_INFO pInfo ) +static BOOL hb_ctw_gt_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_ctw_gt_Info(%d,%p)", iType, pInfo ) ); + HB_TRACE(HB_TR_DEBUG, ("hb_ctw_gt_Info(%p,%d,%p)", pGT, iType, pInfo)); switch ( iType ) { @@ -1388,8 +1407,8 @@ static BOOL hb_ctw_gt_Info( int iType, PHB_GT_INFO pInfo ) { BOOL fResult; - hb_ctw_SelectWindow( 0 ); - fResult = HB_GTSUPER_INFO( iType, pInfo ); + hb_ctw_SelectWindow( pGT, 0 ); + fResult = HB_GTSUPER_INFO( pGT, iType, pInfo ); if( fResult && hb_arrayLen( pInfo->pResult ) >= 8 ) hb_itemPutNI( hb_arrayGetItemPtr( pInfo->pResult, 8 ), @@ -1401,8 +1420,8 @@ static BOOL hb_ctw_gt_Info( int iType, PHB_GT_INFO pInfo ) BOOL fResult; int iWindow = s_iCurrWindow; - hb_ctw_SelectWindow( 0 ); - fResult = HB_GTSUPER_INFO( iType, pInfo ); + hb_ctw_SelectWindow( pGT, 0 ); + fResult = HB_GTSUPER_INFO( pGT, iType, pInfo ); if( fResult && hb_arrayLen( pInfo->pResult ) >= 8 ) hb_itemPutNI( hb_arrayGetItemPtr( pInfo->pResult, 8 ), iWindow ); return fResult; @@ -1411,25 +1430,25 @@ static BOOL hb_ctw_gt_Info( int iType, PHB_GT_INFO pInfo ) { BOOL fResult; - hb_ctw_SelectWindow( 0 ); - fResult = HB_GTSUPER_INFO( iType, pInfo ); + hb_ctw_SelectWindow( pGT, 0 ); + fResult = HB_GTSUPER_INFO( pGT, iType, pInfo ); if( hb_arrayLen( pInfo->pNewVal ) == 8 ) - hb_ctw_SelectWindow( hb_arrayGetNI( pInfo->pNewVal, 8 ) ); + hb_ctw_SelectWindow( pGT, hb_arrayGetNI( pInfo->pNewVal, 8 ) ); return fResult; } default: - return HB_GTSUPER_INFO( iType, pInfo ); + return HB_GTSUPER_INFO( pGT, iType, pInfo ); } return TRUE; } -static int hb_ctw_gt_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, +static int hb_ctw_gt_Alert( PHB_GT pGT, PHB_ITEM pMessage, PHB_ITEM pOptions, int iClrNorm, int iClrHigh, double dDelay ) { int iOptions, iRet = 0; - HB_TRACE( HB_TR_DEBUG, ( "hb_ctw_gt_Alert(%p,%p,%d,%d,%f)", pMessage, pOptions, iClrNorm, iClrHigh, dDelay ) ); + HB_TRACE( HB_TR_DEBUG, ("hb_ctw_gt_Alert(%p,%p,%p,%d,%d,%f)", pGT, pMessage, pOptions, iClrNorm, iClrHigh, dDelay ) ); iOptions = ( int ) hb_arrayLen( pOptions ); @@ -1438,16 +1457,16 @@ static int hb_ctw_gt_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, int iRows, iCols; BOOL fScreen; - hb_gt_GetSize( &iRows, &iCols ); + HB_GTSELF_GETSIZE( pGT, &iRows, &iCols ); if( iCols <= 4 || iRows <= 4 ) fScreen = FALSE; else { HB_GT_INFO gtInfo; gtInfo.pNewVal = gtInfo.pResult = NULL; - hb_gt_Info( GTI_FULLSCREEN, >Info ); + HB_GTSELF_INFO( pGT, GTI_FULLSCREEN, >Info ); fScreen = gtInfo.pResult && hb_itemGetL( gtInfo.pResult ); - hb_gt_Info( GTI_KBDSUPPORT, >Info ); + HB_GTSELF_INFO( pGT, GTI_KBDSUPPORT, >Info ); if( gtInfo.pResult ) { if( !hb_itemGetL( gtInfo.pResult ) ) @@ -1501,13 +1520,13 @@ static int hb_ctw_gt_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, if( iClrHigh == 0 ) iClrHigh = 31; - iDspCount = hb_gt_DispCount(); + iDspCount = HB_GTSELF_DISPCOUNT( pGT ); if( iDspCount == 0 ) - hb_gt_DispBegin(); + HB_GTSELF_DISPBEGIN( pGT ); - iWnd = hb_ctw_CreateWindow( iTop, iLeft, iBottom, iRight, TRUE, iClrNorm ); - hb_ctw_AddWindowBox( iWnd, ( BYTE * ) _B_SINGLE, iClrNorm ); - hb_gt_SetCursorStyle( SC_NONE ); + iWnd = hb_ctw_CreateWindow( pGT, iTop, iLeft, iBottom, iRight, TRUE, iClrNorm ); + hb_ctw_AddWindowBox( pGT, iWnd, ( BYTE * ) _B_SINGLE, iClrNorm ); + HB_GTSELF_SETCURSORSTYLE( pGT, SC_NONE ); ulLast = 0; i = 0; for( ul = 0; ul < ulLen; ++ul ) @@ -1519,8 +1538,8 @@ static int hb_ctw_gt_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, ul2 = ul - ulLast; if( ul2 > ulWidth ) ul2 = ulWidth; - hb_gt_PutText( i, ( ( ulWidth - ul2 + 1 ) >> 1 ) + 1, iClrNorm, - ( BYTE * ) szMessage + ulLast, ul2 ); + HB_GTSELF_PUTTEXT( pGT, i, ( ( ulWidth - ul2 + 1 ) >> 1 ) + 1, iClrNorm, + ( BYTE * ) szMessage + ulLast, ul2 ); } ulLast = ul + 1; if( ++i >= iLines ) @@ -1532,28 +1551,28 @@ static int hb_ctw_gt_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, ul2 = ul - ulLast; if( ul2 > ulWidth ) ul2 = ulWidth; - hb_gt_PutText( i, ( ( ulWidth - ul2 + 1 ) >> 1 ) + 1, iClrNorm, - ( BYTE * ) szMessage + ulLast, ul2 ); + HB_GTSELF_PUTTEXT( pGT, i, ( ( ulWidth - ul2 + 1 ) >> 1 ) + 1, iClrNorm, + ( BYTE * ) szMessage + ulLast, ul2 ); } iPos = 1; while( iRet == 0 ) { - hb_gt_DispBegin(); + HB_GTSELF_DISPBEGIN( pGT ); iMnuCol = ( ( ulWidth - ulCurrWidth ) >> 1 ) + 1; for( i = 1; i <= iOptions; ++i ) { iClr = i == iPos ? iClrHigh : iClrNorm; ulLen = hb_arrayGetCLen( pOptions, i ); - hb_gt_PutText( iLines + 1, iMnuCol, iClr, - ( BYTE * ) hb_arrayGetCPtr( pOptions, i ), ulLen ); + HB_GTSELF_PUTTEXT( pGT, iLines + 1, iMnuCol, iClr, + ( BYTE * ) hb_arrayGetCPtr( pOptions, i ), ulLen ); iMnuCol += ulLen + 3; } - while( hb_gt_DispCount() ) - hb_gt_DispEnd(); - hb_gt_Refresh(); + while( HB_GTSELF_DISPCOUNT( pGT ) ) + HB_GTSELF_DISPEND( pGT ); + HB_GTSELF_REFRESH( pGT ); - iKey = hb_inkey( TRUE, dDelay, INKEY_ALL ); + iKey = HB_GTSELF_INKEYGET( pGT, TRUE, dDelay, INKEY_ALL ); /* TODO: add support for SET KEY blocks */ if( iKey == K_ESC ) @@ -1577,7 +1596,8 @@ static int hb_ctw_gt_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, #ifdef HB_COMPAT_C53 else if( iKey == K_LBUTTONDOWN ) { - int iMRow = hb_mouse_Row(), iMCol = hb_mouse_Col(); + int iMRow = HB_GTSELF_MOUSEROW( pGT ), + iMCol = HB_GTSELF_MOUSECOL( pGT ); if( iMRow == iLines + 1 ) { iMnuCol = ( ( ulWidth - ulCurrWidth ) >> 1 ) + 1; @@ -1609,17 +1629,199 @@ static int hb_ctw_gt_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, } } - hb_ctw_CloseWindow( iWnd ); - hb_gt_Refresh(); + hb_ctw_CloseWindow( pGT, iWnd ); + HB_GTSELF_REFRESH( pGT ); - while( hb_gt_DispCount() < iDspCount ) - hb_gt_DispBegin(); + while( HB_GTSELF_DISPCOUNT( pGT ) < iDspCount ) + HB_GTSELF_DISPBEGIN( pGT ); return iRet; } } - return HB_GTSUPER_ALERT( pMessage, pOptions, iClrNorm, iClrHigh, dDelay ); + return HB_GTSUPER_ALERT( pGT, pMessage, pOptions, iClrNorm, iClrHigh, dDelay ); +} + +/* PUBLIC FUNCTIONS */ + +BOOL hb_ctwInit( void ) +{ + PHB_GT pGT = hb_gt_Base(); + BOOL fResult = FALSE; + if( pGT ) + fResult = hb_ctw_Init( pGT ); + return fResult; +} + +int hb_ctwSetShadowAttr( int iAttr ) +{ + PHB_GT pGT = hb_gt_Base(); + int iResult = -1; + if( pGT ) + iResult = hb_ctw_SetShadowAttr( pGT, iAttr ); + return iResult; +} + +int hb_ctwSetMoveMode( int iMode ) +{ + PHB_GT pGT = hb_gt_Base(); + int iResult = -1; + if( pGT ) + iResult = hb_ctw_SetMoveMode( pGT, iMode ); + return iResult; +} + +int hb_ctwSetMoveStep( int iVertical, int iHorizontal ) +{ + PHB_GT pGT = hb_gt_Base(); + int iResult = -1; + if( pGT ) + iResult = hb_ctw_SetMoveStep( pGT, iVertical, iHorizontal ); + return iResult; +} + +int hb_ctwSetWindowBoard( int iTop, int iLeft, int iBottom, int iRight ) +{ + PHB_GT pGT = hb_gt_Base(); + int iResult = -1; + if( pGT ) + { + iResult = hb_ctw_SetWindowBoard( pGT, iTop, iLeft, iBottom, iRight ); + HB_GTSELF_FLUSH( pGT ); + } + return iResult; +} + +int hb_ctwSetBorderMode( int iTop, int iLeft, int iBottom, int iRight ) +{ + PHB_GT pGT = hb_gt_Base(); + int iResult = -1; + if( pGT ) + iResult = hb_ctw_SetBorderMode( pGT, iTop, iLeft, iBottom, iRight ); + return iResult; +} + +int hb_ctwCreateWindow( int iTop, int iLeft, int iBottom, int iRight, BOOL fClear, int iColor ) +{ + PHB_GT pGT = hb_gt_Base(); + int iResult = -1; + if( pGT ) + { + iResult = hb_ctw_CreateWindow( pGT, iTop, iLeft, iBottom, iRight, fClear, iColor ); + HB_GTSELF_FLUSH( pGT ); + } + return iResult; +} + +int hb_ctwCloseAllWindows( void ) +{ + PHB_GT pGT = hb_gt_Base(); + int iResult = -1; + if( pGT ) + { + iResult = hb_ctw_CloseAllWindows( pGT ); + HB_GTSELF_FLUSH( pGT ); + } + return iResult; +} + +int hb_ctwCloseWindow( int iWindow ) +{ + PHB_GT pGT = hb_gt_Base(); + int iResult = -1; + if( pGT ) + { + iResult = hb_ctw_CloseWindow( pGT, iWindow ); + HB_GTSELF_FLUSH( pGT ); + } + return iResult; +} + +int hb_ctwCurrentWindow( void ) +{ + PHB_GT pGT = hb_gt_Base(); + int iResult = 0; + if( pGT ) + iResult = hb_ctw_CurrentWindow( pGT ); + return iResult; +} + +int hb_ctwSelectWindow( int iWindow ) +{ + PHB_GT pGT = hb_gt_Base(); + int iResult = 0; + if( pGT ) + { + iResult = hb_ctw_SelectWindow( pGT, iWindow ); + HB_GTSELF_FLUSH( pGT ); + } + return iResult; +} + +int hb_ctwMaxWindow( void ) +{ + PHB_GT pGT = hb_gt_Base(); + int iResult = 0; + if( pGT ) + iResult = hb_ctw_MaxWindow( pGT ); + return iResult; +} + +int hb_ctwChangeMargins( int iWindow, int iTop, int iLeft, int iBottom, int iRight ) +{ + PHB_GT pGT = hb_gt_Base(); + int iResult = -1; + if( pGT ) + iResult = hb_ctw_ChangeMargins( pGT, iWindow, iTop, iLeft, iBottom, iRight ); + return iResult; +} + +int hb_ctwGetWindowCords( int iWindow, BOOL fCenter, int * piTop, int * piLeft, int * piBottom, int * piRight ) +{ + PHB_GT pGT = hb_gt_Base(); + int iResult = -1; + if( pGT ) + iResult = hb_ctw_GetWindowCords( pGT, iWindow, fCenter, piTop, piLeft, piBottom, piRight ); + return iResult; +} + +int hb_ctwGetFormatCords( int iWindow, BOOL fRelative, int * piTop, int * piLeft, int * piBottom, int * piRight ) +{ + PHB_GT pGT = hb_gt_Base(); + int iResult = -1; + if( pGT ) + iResult = hb_ctw_GetFormatCords( pGT, iWindow, fRelative, piTop, piLeft, piBottom, piRight ); + return iResult; +} + +int hb_ctwMoveWindow( int iWindow, int iRow, int iCol ) +{ + PHB_GT pGT = hb_gt_Base(); + int iResult = -1; + if( pGT ) + iResult = hb_ctw_MoveWindow( pGT, iWindow, iRow, iCol ); + return iResult; +} + +int hb_ctwCenterWindow( int iWindow, BOOL fCenter ) +{ + PHB_GT pGT = hb_gt_Base(); + int iResult = -1; + if( pGT ) + iResult = hb_ctw_CenterWindow( pGT, iWindow, fCenter ); + return iResult; +} + +int hb_ctwAddWindowBox( int iWindow, BYTE * szBox, int iColor ) +{ + PHB_GT pGT = hb_gt_Base(); + int iResult = -1; + if( pGT ) + { + iResult = hb_ctw_AddWindowBox( pGT, iWindow, szBox, iColor ); + HB_GTSELF_FLUSH( pGT ); + } + return iResult; } diff --git a/harbour/contrib/hbct/ctwin.h b/harbour/contrib/hbct/ctwin.h index bbc4110b3e..18f831b084 100644 --- a/harbour/contrib/hbct/ctwin.h +++ b/harbour/contrib/hbct/ctwin.h @@ -55,24 +55,24 @@ HB_EXTERN_BEGIN -extern BOOL hb_ctw_Init( void ); -extern int hb_ctw_SetShadowAttr( int iAttr ); -extern int hb_ctw_SetMoveMode( int iMode ); -extern int hb_ctw_SetMoveStep( int iVertical, int iHorizontal ); -extern int hb_ctw_SetWindowBoard( int iTop, int iLeft, int iBottom, int iRight ); -extern int hb_ctw_SetBorderMode( int iTop, int iLeft, int iBottom, int iRight ); -extern int hb_ctw_CreateWindow( int iTop, int iLeft, int iBottom, int iRight, BOOL fClear, int iColor ); -extern int hb_ctw_CloseAllWindows( void ); -extern int hb_ctw_CloseWindow( int iWindow ); -extern int hb_ctw_CurrentWindow( void ); -extern int hb_ctw_SelectWindow( int iWindow ); -extern int hb_ctw_MaxWindow( void ); -extern int hb_ctw_ChangeMargins( int iWindow, int iTop, int iLeft, int iBottom, int iRight ); -extern int hb_ctw_GetWindowCords( int iWindow, BOOL fCenter, int * piTop, int * piLeft, int * piBottom, int * piRight ); -extern int hb_ctw_GetFormatCords( int iWindow, BOOL fRelative, int * piTop, int * piLeft, int * piBottom, int * piRight ); -extern int hb_ctw_MoveWindow( int iWindow, int iRow, int iCol ); -extern int hb_ctw_CenterWindow( int iWindow, BOOL fCenter ); -extern int hb_ctw_AddWindowBox( int iWindow, BYTE * szBox, int iColor ); +extern BOOL hb_ctwInit( void ); +extern int hb_ctwSetShadowAttr( int iAttr ); +extern int hb_ctwSetMoveMode( int iMode ); +extern int hb_ctwSetMoveStep( int iVertical, int iHorizontal ); +extern int hb_ctwSetWindowBoard( int iTop, int iLeft, int iBottom, int iRight ); +extern int hb_ctwSetBorderMode( int iTop, int iLeft, int iBottom, int iRight ); +extern int hb_ctwCreateWindow( int iTop, int iLeft, int iBottom, int iRight, BOOL fClear, int iColor ); +extern int hb_ctwCloseAllWindows( void ); +extern int hb_ctwCloseWindow( int iWindow ); +extern int hb_ctwCurrentWindow( void ); +extern int hb_ctwSelectWindow( int iWindow ); +extern int hb_ctwMaxWindow( void ); +extern int hb_ctwChangeMargins( int iWindow, int iTop, int iLeft, int iBottom, int iRight ); +extern int hb_ctwGetWindowCords( int iWindow, BOOL fCenter, int * piTop, int * piLeft, int * piBottom, int * piRight ); +extern int hb_ctwGetFormatCords( int iWindow, BOOL fRelative, int * piTop, int * piLeft, int * piBottom, int * piRight ); +extern int hb_ctwMoveWindow( int iWindow, int iRow, int iCol ); +extern int hb_ctwCenterWindow( int iWindow, BOOL fCenter ); +extern int hb_ctwAddWindowBox( int iWindow, BYTE * szBox, int iColor ); HB_EXTERN_END diff --git a/harbour/contrib/hbgtwvg/gtwvt.c b/harbour/contrib/hbgtwvg/gtwvt.c index 20f234f8af..b52c1d10d7 100644 --- a/harbour/contrib/hbgtwvg/gtwvt.c +++ b/harbour/contrib/hbgtwvg/gtwvt.c @@ -118,7 +118,7 @@ static COLORREF _COLORS[] = { BRIGHT_WHITE }; -static int K_Ctrl[] = +static const int K_Ctrl[] = { K_CTRL_A, K_CTRL_B, K_CTRL_C, K_CTRL_D, K_CTRL_E, K_CTRL_F, K_CTRL_G, K_CTRL_H, K_CTRL_I, K_CTRL_J, K_CTRL_K, K_CTRL_L, K_CTRL_M, K_CTRL_N, @@ -247,20 +247,21 @@ static void hb_wvt_gtCreateObjects( void ) //-------------------------------------------------------------------// -static void hb_gt_wvt_InitStatics( void ) +static void hb_gt_wvt_InitStatics( PHB_GT pGT ) { OSVERSIONINFO osvi; osvi.dwOSVersionInfoSize = sizeof( OSVERSIONINFO ); GetVersionEx( &osvi ); + _s.pGT = pGT; _s.ROWS = WVT_DEFAULT_ROWS; _s.COLS = WVT_DEFAULT_COLS; _s.CaretExist = FALSE; _s.CaretHidden = FALSE; _s.CaretSize = 4; - _s.mousePos.x = 0; - _s.mousePos.y = 0; + _s.MousePos.x = 0; + _s.MousePos.y = 0; _s.MouseMove = TRUE; _s.hWnd = NULL; _s.keyPointerIn = 0; @@ -289,7 +290,7 @@ static void hb_gt_wvt_InitStatics( void ) static BOOL hb_gt_wvt_SetWindowSize( int iRow, int iCol ) { - if( HB_GTSUPER_RESIZE( iRow, iCol ) ) + if( HB_GTSUPER_RESIZE( _s.pGT, iRow, iCol ) ) { _s.ROWS = ( USHORT ) iRow; _s.COLS = ( USHORT ) iCol; @@ -587,8 +588,8 @@ static int hb_gt_wvt_key_ansi_to_oem( int c ) static void hb_gt_wvt_SetMousePos( int iRow, int iCol ) { - _s.mousePos.y = ( SHORT ) iRow; - _s.mousePos.x = ( SHORT ) iCol; + _s.MousePos.y = ( SHORT ) iRow; + _s.MousePos.x = ( SHORT ) iCol; } static void hb_gt_wvt_MouseEvent( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam ) @@ -1101,7 +1102,7 @@ static void hb_gt_wvt_PaintText( HWND hWnd, RECT updateRect ) while( iCol <= rcRect.right ) { - if( !hb_gt_GetScrChar( iRow, iCol, &bColor, &bAttr, &usChar ) ) + if( !HB_GTSELF_GETSCRCHAR( _s.pGT, iRow, iCol, &bColor, &bAttr, &usChar ) ) break; #if defined(UNICODE) @@ -1160,7 +1161,7 @@ static void hb_gt_wvt_UpdateCaret( void ) { int iRow, iCol, iStyle, iCaretSize; - hb_gt_GetScrCursor( &iRow, &iCol, &iStyle ); + HB_GTSELF_GETSCRCURSOR( _s.pGT, &iRow, &iCol, &iStyle ); if( iRow < 0 || iCol < 0 || iRow >= _s.ROWS || iCol >= _s.COLS ) { @@ -1946,16 +1947,17 @@ BOOL HB_EXPORT hb_wvt_gtSetFont( char *fontFace, int height, int width, int Bold */ /* ********************************************************************** */ -static void hb_gt_wvt_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) +static void hb_gt_wvt_Init( PHB_GT pGT, FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Init(%p,%p,%p)", hFilenoStdin, hFilenoStdout, hFilenoStderr ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Init(%p,%p,%p,%p)", pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr ) ); if( ! hb_winmainArgGet( &s_hInstance, &s_hPrevInstance, &s_iCmdShow ) ) { hb_errInternal( 10001, "It's not a window GUI program.", "", "" ); } - hb_gt_wvt_InitStatics(); + hb_gt_wvt_InitStatics( pGT ); + HB_GTLOCAL( pGT ) = ( void * ) &_s; _s.hWnd = hb_gt_wvt_CreateWindow( ( HINSTANCE ) s_hInstance, ( HINSTANCE ) s_hPrevInstance, "", s_iCmdShow ); @@ -1987,18 +1989,18 @@ static void hb_gt_wvt_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE } /* SUPER GT initialization */ - HB_GTSUPER_INIT( hFilenoStdin, hFilenoStdout, hFilenoStderr ); - HB_GTSUPER_RESIZE( _s.ROWS, _s.COLS ); - HB_GTSUPER_EXPOSEAREA( 0, 0, _s.ROWS, _s.COLS ); + HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr ); + HB_GTSUPER_RESIZE( pGT, _s.ROWS, _s.COLS ); + HB_GTSUPER_EXPOSEAREA( pGT, 0, 0, _s.ROWS, _s.COLS ); } /* ********************************************************************** */ -static void hb_gt_wvt_Exit( void ) +static void hb_gt_wvt_Exit( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_wvt_Exit()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_wvt_Exit(%p)", pGT)); - HB_GTSUPER_EXIT(); + HB_GTSUPER_EXIT( pGT ); if( _s.hWnd ) { @@ -2011,11 +2013,13 @@ static void hb_gt_wvt_Exit( void ) /* ********************************************************************** */ -static BOOL hb_gt_wvt_SetMode( int iRow, int iCol ) +static BOOL hb_gt_wvt_SetMode( PHB_GT pGT, int iRow, int iCol ) { BOOL fResult = FALSE; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_SetMode( %hu, %hu )", iRow, iCol ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_SetMode(%p,%d,%d)", pGT, iRow, iCol ) ); + + HB_SYMBOL_UNUSED( pGT ); if( iRow <= WVT_MAX_ROWS && iCol <= WVT_MAX_COLS ) { @@ -2048,9 +2052,11 @@ static BOOL hb_gt_wvt_SetMode( int iRow, int iCol ) /* ********************************************************************** */ -static char * hb_gt_wvt_Version( int iType ) +static char * hb_gt_wvt_Version( PHB_GT pGT, int iType ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Version()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Version(%p,%d)", pGT, iType ) ); + + HB_SYMBOL_UNUSED( pGT ); if( iType == 0 ) return HB_GT_DRVNAME( HB_GT_NAME ); @@ -2060,13 +2066,14 @@ static char * hb_gt_wvt_Version( int iType ) /* ********************************************************************** */ -static int hb_gt_wvt_ReadKey( int iEventMask ) +static int hb_gt_wvt_ReadKey( PHB_GT pGT, int iEventMask ) { int c = 0; BOOL fKey; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_ReadKey( %d )", iEventMask ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_ReadKey(%p,%d)", pGT, iEventMask ) ); + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( iEventMask ); /* we ignore the eventmask! */ hb_gt_wvt_ProcessMessages(); @@ -2077,33 +2084,41 @@ static int hb_gt_wvt_ReadKey( int iEventMask ) /* ********************************************************************** */ /* dDuration is in 'Ticks' (18.2 per second) */ -static void hb_gt_wvt_Tone( double dFrequency, double dDuration ) +static void hb_gt_wvt_Tone( PHB_GT pGT, double dFrequency, double dDuration ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_wvt_Tone(%lf, %lf)", dFrequency, dDuration)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_wvt_Tone(%p,%lf,%lf)", pGT, dFrequency, dDuration)); + + HB_SYMBOL_UNUSED( pGT ); hb_gt_w32_tone( dFrequency, dDuration ); } /* ********************************************************************** */ -static BOOL hb_gt_wvt_mouse_IsPresent( void ) +static BOOL hb_gt_wvt_mouse_IsPresent( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_wvt_mouse_IsPresent()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_wvt_mouse_IsPresent(%p)", pGT)); + + HB_SYMBOL_UNUSED( pGT ); return TRUE; } -static void hb_gt_wvt_mouse_GetPos( int * piRow, int * piCol ) +static void hb_gt_wvt_mouse_GetPos( PHB_GT pGT, int * piRow, int * piCol ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_wvt_mouse_GetPos(%p,%p)", piRow, piCol)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_wvt_mouse_GetPos(%p,%p,%p)", pGT, piRow, piCol)); - *piRow = _s.mousePos.y; - *piCol = _s.mousePos.x; + HB_SYMBOL_UNUSED( pGT ); + + *piRow = _s.MousePos.y; + *piCol = _s.MousePos.x; } -static BOOL hb_gt_wvt_mouse_ButtonState( int iButton ) +static BOOL hb_gt_wvt_mouse_ButtonState( PHB_GT pGT, int iButton ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_mouse_ButtonState(%i)", iButton ) ); + HB_TRACE( HB_TR_DEBUG, ("hb_gt_wvt_mouse_ButtonState(%p,%i)", pGT, iButton) ); + + HB_SYMBOL_UNUSED( pGT ); switch( iButton ) { @@ -2117,20 +2132,22 @@ static BOOL hb_gt_wvt_mouse_ButtonState( int iButton ) return FALSE; } -static int hb_gt_wvt_mouse_CountButton( void ) +static int hb_gt_wvt_mouse_CountButton( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_mouse_CountButton()") ); + HB_TRACE( HB_TR_DEBUG, ("hb_gt_wvt_mouse_CountButton(%p)", pGT) ); + + HB_SYMBOL_UNUSED( pGT ); return GetSystemMetrics( SM_CMOUSEBUTTONS ); } /* ********************************************************************** */ -static BOOL hb_gt_wvt_Info( int iType, PHB_GT_INFO pInfo ) +static BOOL hb_gt_wvt_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) { int iVal; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Info(%d,%p)", iType, pInfo ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Info(%p,%d,%p)", pGT, iType, pInfo ) ); switch( iType ) { @@ -2278,7 +2295,7 @@ static BOOL hb_gt_wvt_Info( int iType, PHB_GT_INFO pInfo ) iVal = hb_itemGetNI( pInfo->pNewVal ); if( iVal > 0 ) { - hb_gtSetMode( (USHORT) ( iVal / _s.PTEXTSIZE.y ), _s.COLS ); + HB_GTSELF_SETMODE( pGT, (USHORT) ( iVal / _s.PTEXTSIZE.y ), _s.COLS ); } break; @@ -2287,7 +2304,7 @@ static BOOL hb_gt_wvt_Info( int iType, PHB_GT_INFO pInfo ) iVal = hb_itemGetNI( pInfo->pNewVal ); if( iVal > 0 ) { - hb_gtSetMode( _s.ROWS, (USHORT) ( iVal / _s.PTEXTSIZE.x ) ); + HB_GTSELF_SETMODE( pGT, _s.ROWS, (USHORT) ( iVal / _s.PTEXTSIZE.x ) ); } break; @@ -2440,7 +2457,7 @@ static BOOL hb_gt_wvt_Info( int iType, PHB_GT_INFO pInfo ) break; default: - return HB_GTSUPER_INFO( iType, pInfo ); + return HB_GTSUPER_INFO( pGT, iType, pInfo ); } return TRUE; @@ -2476,14 +2493,16 @@ static BOOL hb_gt_wvt_Info( int iType, PHB_GT_INFO pInfo ) ReleaseDC( _s.hWnd, hdc ); \ } while( 0 ) -static int hb_gt_wvt_gfx_Primitive( int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor ) +static int hb_gt_wvt_gfx_Primitive( PHB_GT pGT, int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor ) { HDC hdc; HPEN hPen, hOldPen; HBRUSH hBrush, hOldBrush; int iRet = 0; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_gfx_Primitive(%d, %d, %d, %d, %d, %d)", iType, iTop, iLeft, iBottom, iRight, iColor ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_gfx_Primitive(%p,%d,%d,%d,%d,%d,%d)", pGT, iType, iTop, iLeft, iBottom, iRight, iColor ) ); + + HB_SYMBOL_UNUSED( pGT ); if( _s.hWnd ) { @@ -2595,8 +2614,9 @@ static int hb_gt_wvt_gfx_Primitive( int iType, int iTop, int iLeft, int iBottom, } /* -static void hb_gt_wvt_gfx_Text( int iTop, int iLeft, char *cBuf, int iColor, int iSize, int iWidth ) +static void hb_gt_wvt_gfx_Text( PHB_GT pGT, int iTop, int iLeft, char *cBuf, int iColor, int iSize, int iWidth ) { + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( iTop ); HB_SYMBOL_UNUSED( iLeft ); HB_SYMBOL_UNUSED( cBuf ); @@ -2608,9 +2628,11 @@ static void hb_gt_wvt_gfx_Text( int iTop, int iLeft, char *cBuf, int iColor, int /* ********************************************************************** */ -static void hb_gt_wvt_Redraw( int iRow, int iCol, int iSize ) +static void hb_gt_wvt_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Redraw(%d, %d, %d)", iRow, iCol, iSize ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Redraw(%p,%d,%d,%d)", pGT, iRow, iCol, iSize ) ); + + HB_SYMBOL_UNUSED( pGT ); if( _s.hWnd ) { @@ -2628,11 +2650,11 @@ static void hb_gt_wvt_Redraw( int iRow, int iCol, int iSize ) /* ********************************************************************** */ -static void hb_gt_wvt_Refresh( void ) +static void hb_gt_wvt_Refresh( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Refresh()") ); + HB_TRACE( HB_TR_DEBUG, ("hb_gt_wvt_Refresh(%p)", pGT) ); - HB_GTSUPER_REFRESH(); + HB_GTSUPER_REFRESH( pGT ); if( _s.hWnd ) { @@ -2643,10 +2665,9 @@ static void hb_gt_wvt_Refresh( void ) /* ********************************************************************** */ -static BOOL hb_gt_wvt_SetDispCP( char * pszTermCDP, char * pszHostCDP, BOOL fBox ) +static BOOL hb_gt_wvt_SetDispCP( PHB_GT pGT, char * pszTermCDP, char * pszHostCDP, BOOL fBox ) { - - HB_GTSUPER_SETDISPCP( pszTermCDP, pszHostCDP, fBox ); + HB_GTSUPER_SETDISPCP( pGT, pszTermCDP, pszHostCDP, fBox ); #ifndef HB_CDP_SUPPORT_OFF /* @@ -2672,9 +2693,9 @@ static BOOL hb_gt_wvt_SetDispCP( char * pszTermCDP, char * pszHostCDP, BOOL fBox return TRUE; } -static BOOL hb_gt_wvt_SetKeyCP( char * pszTermCDP, char * pszHostCDP ) +static BOOL hb_gt_wvt_SetKeyCP( PHB_GT pGT, char * pszTermCDP, char * pszHostCDP ) { - HB_GTSUPER_SETKEYCP( pszTermCDP, pszHostCDP ); + HB_GTSUPER_SETKEYCP( pGT, pszTermCDP, pszHostCDP ); #ifndef HB_CDP_SUPPORT_OFF /* diff --git a/harbour/contrib/hbgtwvg/gtwvt.h b/harbour/contrib/hbgtwvg/gtwvt.h index 9fc00d5edd..9074756c23 100644 --- a/harbour/contrib/hbgtwvg/gtwvt.h +++ b/harbour/contrib/hbgtwvg/gtwvt.h @@ -186,6 +186,8 @@ typedef BOOL ( WINAPI *wvtGradientFill ) ( typedef struct global_data { + PHB_GT pGT; /* core GT pointer */ + USHORT ROWS; /* number of displayable rows in window */ USHORT COLS; /* number of displayable columns in window */ @@ -193,7 +195,7 @@ typedef struct global_data BOOL CaretHidden; /* TRUE if a caret has been hiden */ int CaretSize; /* Size of solid caret */ - POINT mousePos; /* the last mouse position */ + POINT MousePos; /* the last mouse position */ BOOL MouseMove; /* Flag to say whether to return mouse movement events */ int Keys[ WVT_CHAR_QUEUE_SIZE ]; /* Array to hold the characters & events */ diff --git a/harbour/contrib/hbgtwvg/wvtutils.c b/harbour/contrib/hbgtwvg/wvtutils.c index 3d4f7ae2a3..e454da2ba5 100644 --- a/harbour/contrib/hbgtwvg/wvtutils.c +++ b/harbour/contrib/hbgtwvg/wvtutils.c @@ -177,11 +177,12 @@ HB_FUNC( WVT_CHOOSEFONT ) if ( ChooseFont( &cf ) ) { + char * szFaceName = HB_TCHAR_CONVFROM( lf.lfFaceName ); + PointSize = -MulDiv( lf.lfHeight, 72, GetDeviceCaps( _s->hdc, LOGPIXELSY ) ) ; hb_reta( 8 ); - - hb_storc( HB_TCHAR_CONVFROM( lf.lfFaceName ), -1, 1 ); + hb_storc( szFaceName , -1, 1 ); hb_stornl( ( LONG ) PointSize, -1, 2 ); hb_storni( lf.lfWidth , -1, 3 ); hb_storni( lf.lfWeight , -1, 4 ); @@ -189,6 +190,8 @@ HB_FUNC( WVT_CHOOSEFONT ) hb_storl( lf.lfItalic , -1, 6 ); hb_storl( lf.lfUnderline , -1, 7 ); hb_storl( lf.lfStrikeOut , -1, 8 ); + + HB_TCHAR_FREE( szFaceName ); } else { @@ -277,7 +280,7 @@ HB_FUNC( WVT_SETTOOLTIPACTIVE ) // HB_FUNC( WVT_SETTOOLTIP ) { - TOOLINFO ti = { 0,0,0,0,0,0,0,0 }; + TOOLINFO ti; POINT xy = { 0,0 }; int iTop, iLeft, iBottom, iRight; @@ -286,6 +289,7 @@ HB_FUNC( WVT_SETTOOLTIP ) return; } + memset( &ti, 0, sizeof( ti ) ); ti.cbSize = sizeof( TOOLINFO ); ti.hwnd = _s->hWnd; ti.uId = 100000; @@ -1648,9 +1652,11 @@ HB_FUNC( WIN_SENDMESSAGE ) ( LPARAM ) hb_parnl( 4 ) ) ) ) ) ); - if ( cText ) + if( cText ) { - hb_storc( HB_TCHAR_CONVFROM( cText ), 4 ); + char * szText = HB_TCHAR_CONVFROM( cText ); + hb_storc( szText, 4 ); + HB_TCHAR_FREE( szText ); HB_TCHAR_FREE( cText ); } } @@ -1798,15 +1804,19 @@ HB_FUNC( WIN_SETDLGITEMTEXT ) HB_FUNC( WIN_GETDLGITEMTEXT ) { USHORT iLen = SendMessage( GetDlgItem( ( HWND ) hb_parnl( 1 ), hb_parni( 2 ) ), WM_GETTEXTLENGTH, 0, 0 ) + 1 ; - char *cText = ( char* ) hb_xgrab( iLen * sizeof( TCHAR ) ); + LPTSTR cText = ( LPTSTR ) hb_xgrab( iLen * sizeof( TCHAR ) ); + char * szText; GetDlgItemText( ( HWND ) hb_parnl( 1 ), // handle of dialog box hb_parni( 2 ), // identifier of control - ( LPTSTR ) cText, // address of buffer for text + cText, // address of buffer for text iLen // maximum size of string ); - hb_retc( HB_TCHAR_CONVFROM( cText ) ); + + szText = HB_TCHAR_CONVFROM( cText ); + hb_retc( szText ); + HB_TCHAR_FREE( szText ); HB_TCHAR_FREE( cText ); } @@ -2273,7 +2283,7 @@ HB_FUNC( WVT__GETOPENFILENAME ) hb_stornl( ofn.nFilterIndex, 8 ); hb_storclen( szFileName, size, 2 ) ; hb_retc( szFileName ); - + HB_TCHAR_FREE( szFileName ); } else { diff --git a/harbour/include/hbgtcore.h b/harbour/include/hbgtcore.h index 98d1545a1d..3ef00c4d54 100644 --- a/harbour/include/hbgtcore.h +++ b/harbour/include/hbgtcore.h @@ -111,148 +111,150 @@ /* forward declaration */ struct _HB_GT_BASE; +#define HB_GT_PTR struct _HB_GT_BASE * + typedef struct { - void (* Init) ( FHANDLE, FHANDLE, FHANDLE ); - void (* Exit) ( void ); - void * (* New) ( void ); - void (* Free) ( void * ); - BOOL (* Resize ) ( int, int ); - BOOL (* SetMode) ( int, int ); - void (* GetSize) ( int *, int * ); - void (* SemiCold) ( void ); - void (* ColdArea) ( int, int, int, int ); - void (* ExposeArea) ( int, int, int, int ); - void (* ScrollArea) ( int, int, int, int, BYTE, BYTE, int, int ); - void (* TouchCell) ( int, int ); - void (* Redraw) ( int, int, int ); - void (* Refresh) ( void ); - void (* Flush) ( void ); - int (* MaxCol) ( void ); - int (* MaxRow) ( void ); - BOOL (* CheckPos) ( int, int, long * ); - void (* SetPos) ( int, int ); - void (* GetPos) ( int *, int * ); - BOOL (* IsColor) ( void ); - void (* GetColorStr) ( char * ); - void (* SetColorStr) ( const char * ); - void (* ColorSelect) ( int ); - int (* GetColor) ( void ); - int (* ColorNum) ( const char * ); - void (* ColorsToString) ( int *, int, char *, int ); - void (* StringToColors) ( const char *, int **, int * ); - void (* GetColorData) ( int **, int *, int * ); - int (* GetClearColor) ( void ); - void (* SetClearColor) ( int ); - int (* GetClearChar) ( void ); - void (* SetClearChar) ( int ); - int (* GetCursorStyle) ( void ); - void (* SetCursorStyle) ( int ); - void (* GetScrCursor) ( int *, int *, int * ); - BOOL (* GetScrChar) ( int, int, BYTE *, BYTE *, USHORT * ); - BOOL (* PutScrChar) ( int, int, BYTE, BYTE, USHORT ); - void (* DispBegin) ( void ); - void (* DispEnd) ( void ); - int (* DispCount) ( void ); - BOOL (* GetChar) ( int, int, BYTE *, BYTE *, USHORT * ); - BOOL (* PutChar) ( int, int, BYTE, BYTE, USHORT ); - long (* RectSize) ( int, int, int, int ); - void (* Save) ( int, int, int, int, BYTE * ); - void (* Rest) ( int, int, int, int, BYTE * ); - void (* PutText) ( int, int, BYTE, BYTE *, ULONG ); - void (* Replicate) ( int, int, BYTE, BYTE, USHORT, ULONG ); - void (* WriteAt) ( int, int, BYTE *, ULONG ); - void (* Write) ( BYTE *, ULONG ); - void (* WriteCon) ( BYTE *, ULONG ); - void (* SetAttribute) ( int, int, int, int, BYTE ); - void (* DrawShadow) ( int, int, int, int, BYTE ); - void (* Scroll) ( int, int, int, int, BYTE, BYTE, int, int ); - void (* ScrollUp) ( int, BYTE, BYTE ); - void (* Box) ( int, int, int, int, BYTE *, BYTE ); - void (* BoxD) ( int, int, int, int, BYTE *, BYTE ); - void (* BoxS) ( int, int, int, int, BYTE *, BYTE ); - void (* HorizLine) ( int, int, int, BYTE, BYTE ); - void (* VertLine) ( int, int, int, BYTE, BYTE ); - BOOL (* GetBlink) ( void ); - void (* SetBlink) ( BOOL ); - void (* SetSnowFlag) ( BOOL ); - char * (* Version) ( int ); - BOOL (* Suspend) ( void ); - BOOL (* Resume) ( void ); - BOOL (* PreExt) ( void ); - BOOL (* PostExt) ( void ); - void (* OutStd) ( BYTE *, ULONG ); - void (* OutErr) ( BYTE *, ULONG ); - void (* Tone) ( double, double ); - void (* Bell) ( void ); - BOOL (* Info) ( int, PHB_GT_INFO ); - int (* Alert) ( PHB_ITEM, PHB_ITEM, int, int, double ); - int (* SetFlag) ( int, int ); + void (* Init) ( HB_GT_PTR, FHANDLE, FHANDLE, FHANDLE ); + void (* Exit) ( HB_GT_PTR ); + void * (* New) ( HB_GT_PTR ); + void (* Free) ( HB_GT_PTR ); + BOOL (* Resize ) ( HB_GT_PTR, int, int ); + BOOL (* SetMode) ( HB_GT_PTR, int, int ); + void (* GetSize) ( HB_GT_PTR, int *, int * ); + void (* SemiCold) ( HB_GT_PTR ); + void (* ColdArea) ( HB_GT_PTR, int, int, int, int ); + void (* ExposeArea) ( HB_GT_PTR, int, int, int, int ); + void (* ScrollArea) ( HB_GT_PTR, int, int, int, int, BYTE, BYTE, int, int ); + void (* TouchCell) ( HB_GT_PTR, int, int ); + void (* Redraw) ( HB_GT_PTR, int, int, int ); + void (* Refresh) ( HB_GT_PTR ); + void (* Flush) ( HB_GT_PTR ); + int (* MaxCol) ( HB_GT_PTR ); + int (* MaxRow) ( HB_GT_PTR ); + BOOL (* CheckPos) ( HB_GT_PTR, int, int, long * ); + void (* SetPos) ( HB_GT_PTR, int, int ); + void (* GetPos) ( HB_GT_PTR, int *, int * ); + BOOL (* IsColor) ( HB_GT_PTR ); + void (* GetColorStr) ( HB_GT_PTR, char * ); + void (* SetColorStr) ( HB_GT_PTR, const char * ); + void (* ColorSelect) ( HB_GT_PTR, int ); + int (* GetColor) ( HB_GT_PTR ); + int (* ColorNum) ( HB_GT_PTR, const char * ); + void (* ColorsToString) ( HB_GT_PTR, int *, int, char *, int ); + void (* StringToColors) ( HB_GT_PTR, const char *, int **, int * ); + void (* GetColorData) ( HB_GT_PTR, int **, int *, int * ); + int (* GetClearColor) ( HB_GT_PTR ); + void (* SetClearColor) ( HB_GT_PTR, int ); + int (* GetClearChar) ( HB_GT_PTR ); + void (* SetClearChar) ( HB_GT_PTR, int ); + int (* GetCursorStyle) ( HB_GT_PTR ); + void (* SetCursorStyle) ( HB_GT_PTR, int ); + void (* GetScrCursor) ( HB_GT_PTR, int *, int *, int * ); + BOOL (* GetScrChar) ( HB_GT_PTR, int, int, BYTE *, BYTE *, USHORT * ); + BOOL (* PutScrChar) ( HB_GT_PTR, int, int, BYTE, BYTE, USHORT ); + void (* DispBegin) ( HB_GT_PTR ); + void (* DispEnd) ( HB_GT_PTR ); + int (* DispCount) ( HB_GT_PTR ); + BOOL (* GetChar) ( HB_GT_PTR, int, int, BYTE *, BYTE *, USHORT * ); + BOOL (* PutChar) ( HB_GT_PTR, int, int, BYTE, BYTE, USHORT ); + long (* RectSize) ( HB_GT_PTR, int, int, int, int ); + void (* Save) ( HB_GT_PTR, int, int, int, int, BYTE * ); + void (* Rest) ( HB_GT_PTR, int, int, int, int, BYTE * ); + void (* PutText) ( HB_GT_PTR, int, int, BYTE, BYTE *, ULONG ); + void (* Replicate) ( HB_GT_PTR, int, int, BYTE, BYTE, USHORT, ULONG ); + void (* WriteAt) ( HB_GT_PTR, int, int, BYTE *, ULONG ); + void (* Write) ( HB_GT_PTR, BYTE *, ULONG ); + void (* WriteCon) ( HB_GT_PTR, BYTE *, ULONG ); + void (* SetAttribute) ( HB_GT_PTR, int, int, int, int, BYTE ); + void (* DrawShadow) ( HB_GT_PTR, int, int, int, int, BYTE ); + void (* Scroll) ( HB_GT_PTR, int, int, int, int, BYTE, BYTE, int, int ); + void (* ScrollUp) ( HB_GT_PTR, int, BYTE, BYTE ); + void (* Box) ( HB_GT_PTR, int, int, int, int, BYTE *, BYTE ); + void (* BoxD) ( HB_GT_PTR, int, int, int, int, BYTE *, BYTE ); + void (* BoxS) ( HB_GT_PTR, int, int, int, int, BYTE *, BYTE ); + void (* HorizLine) ( HB_GT_PTR, int, int, int, BYTE, BYTE ); + void (* VertLine) ( HB_GT_PTR, int, int, int, BYTE, BYTE ); + BOOL (* GetBlink) ( HB_GT_PTR ); + void (* SetBlink) ( HB_GT_PTR, BOOL ); + void (* SetSnowFlag) ( HB_GT_PTR, BOOL ); + char * (* Version) ( HB_GT_PTR, int ); + BOOL (* Suspend) ( HB_GT_PTR ); + BOOL (* Resume) ( HB_GT_PTR ); + BOOL (* PreExt) ( HB_GT_PTR ); + BOOL (* PostExt) ( HB_GT_PTR ); + void (* OutStd) ( HB_GT_PTR, BYTE *, ULONG ); + void (* OutErr) ( HB_GT_PTR, BYTE *, ULONG ); + void (* Tone) ( HB_GT_PTR, double, double ); + void (* Bell) ( HB_GT_PTR ); + BOOL (* Info) ( HB_GT_PTR, int, PHB_GT_INFO ); + int (* Alert) ( HB_GT_PTR, PHB_ITEM, PHB_ITEM, int, int, double ); + int (* SetFlag) ( HB_GT_PTR, int, int ); /* internationalization */ - BOOL (* SetDispCP) ( char *, char *, BOOL ); - BOOL (* SetKeyCP) ( char *, char * ); + BOOL (* SetDispCP) ( HB_GT_PTR, char *, char *, BOOL ); + BOOL (* SetKeyCP) ( HB_GT_PTR, char *, char * ); /* keyboard */ - int (* ReadKey) ( int ); + int (* ReadKey) ( HB_GT_PTR, int ); - int (* InkeyGet) ( BOOL fWait, double dSeconds, int iEventMask ); - void (* InkeyPut) ( int iKey ); - int (* InkeyLast) ( int iEventMask ); - int (* InkeyNext) ( int iEventMask ); - void (* InkeyPoll) ( void ); - void (* InkeySetText) ( const char * szText, ULONG ulLen ); - int (* InkeySetLast) ( int iKey ); - void (* InkeyReset) ( void ); - void (* InkeyExit) ( void ); + int (* InkeyGet) ( HB_GT_PTR, BOOL fWait, double dSeconds, int iEventMask ); + void (* InkeyPut) ( HB_GT_PTR, int iKey ); + int (* InkeyLast) ( HB_GT_PTR, int iEventMask ); + int (* InkeyNext) ( HB_GT_PTR, int iEventMask ); + void (* InkeyPoll) ( HB_GT_PTR ); + void (* InkeySetText) ( HB_GT_PTR, const char * szText, ULONG ulLen ); + int (* InkeySetLast) ( HB_GT_PTR, int iKey ); + void (* InkeyReset) ( HB_GT_PTR ); + void (* InkeyExit) ( HB_GT_PTR ); /* mouse */ - void (* MouseInit) ( void ); - void (* MouseExit) ( void ); - BOOL (* MouseIsPresent) ( void ); - void (* MouseShow) ( void ); - void (* MouseHide) ( void ); - BOOL (* MouseGetCursor) ( void ); - void (* MouseSetCursor) ( BOOL ); - int (* MouseCol) ( void ); - int (* MouseRow) ( void ); - void (* MouseGetPos) ( int *, int * ); - void (* MouseSetPos) ( int, int ); - void (* MouseSetBounds) ( int, int, int, int ); - void (* MouseGetBounds) ( int *, int *, int *, int * ); - int (* MouseStorageSize) ( void ); - void (* MouseSaveState) ( BYTE * ); - void (* MouseRestoreState) ( BYTE * ); - int (* MouseGetDoubleClickSpeed) ( void ); - void (* MouseSetDoubleClickSpeed) ( int ); - int (* MouseCountButton) ( void ); - BOOL (* MouseButtonState) ( int ); - BOOL (* MouseButtonPressed) ( int, int *, int * ); - BOOL (* MouseButtonReleased) ( int, int *, int * ); - int (* MouseReadKey) ( int ); + void (* MouseInit) ( HB_GT_PTR ); + void (* MouseExit) ( HB_GT_PTR ); + BOOL (* MouseIsPresent) ( HB_GT_PTR ); + void (* MouseShow) ( HB_GT_PTR ); + void (* MouseHide) ( HB_GT_PTR ); + BOOL (* MouseGetCursor) ( HB_GT_PTR ); + void (* MouseSetCursor) ( HB_GT_PTR, BOOL ); + int (* MouseCol) ( HB_GT_PTR ); + int (* MouseRow) ( HB_GT_PTR ); + void (* MouseGetPos) ( HB_GT_PTR, int *, int * ); + void (* MouseSetPos) ( HB_GT_PTR, int, int ); + void (* MouseSetBounds) ( HB_GT_PTR, int, int, int, int ); + void (* MouseGetBounds) ( HB_GT_PTR, int *, int *, int *, int * ); + int (* MouseStorageSize) ( HB_GT_PTR ); + void (* MouseSaveState) ( HB_GT_PTR, BYTE * ); + void (* MouseRestoreState) ( HB_GT_PTR, BYTE * ); + int (* MouseGetDoubleClickSpeed) ( HB_GT_PTR ); + void (* MouseSetDoubleClickSpeed) ( HB_GT_PTR, int ); + int (* MouseCountButton) ( HB_GT_PTR ); + BOOL (* MouseButtonState) ( HB_GT_PTR, int ); + BOOL (* MouseButtonPressed) ( HB_GT_PTR, int, int *, int * ); + BOOL (* MouseButtonReleased) ( HB_GT_PTR, int, int *, int * ); + int (* MouseReadKey) ( HB_GT_PTR, int ); /* Graphics API */ - int (* GfxPrimitive) ( int, int, int, int, int, int ); - void (* GfxText) ( int, int, char *, int, int, int ); + int (* GfxPrimitive) ( HB_GT_PTR, int, int, int, int, int, int ); + void (* GfxText) ( HB_GT_PTR, int, int, char *, int, int, int ); #if 0 /* keyboard */ - int (* ExtendedKeySupport) ( void ); + int (* ExtendedKeySupport) ( HB_GT_PTR ); /* GT CLIPBOARD functions */ - void (* GetClipboard) ( char *, ULONG * ); - void (* SetClipboard) ( char *, ULONG ); - ULONG (* GetClipboardSize) ( void ); + void (* GetClipboard) ( HB_GT_PTR, char *, ULONG * ); + void (* SetClipboard) ( HB_GT_PTR, char *, ULONG ); + ULONG (* GetClipboardSize) ( HB_GT_PTR ); - void (* ProcessMessages) ( void ); + void (* ProcessMessages) ( HB_GT_PTR ); /* GT to DRIVER communication functions */ - void (* update ) ( int ); - int (* info ) ( int, BOOL , int , void * ); + void (* update ) ( HB_GT_PTR, int ); + int (* info ) ( HB_GT_PTR, int, BOOL , int , void * ); #endif - void (* WhoCares) ( void * ); + void (* WhoCares) ( HB_GT_PTR, void * ); } HB_GT_FUNCS, * PHB_GT_FUNCS; @@ -360,125 +362,13 @@ typedef struct _HB_GT_BASE ULONG StrBufferSize; ULONG StrBufferPos; - void ** pGTData; /* */ + void * pGTData[HB_GT_MAX_]; /* local GT data */ } HB_GT_BASE, * PHB_GT_BASE, * PHB_GT; extern PHB_GT hb_gt_Base( void ); -extern void hb_gt_Init( FHANDLE hStdIn, FHANDLE hStdOut, FHANDLE hStdErr ); -extern void hb_gt_Exit( void ); -extern void * hb_gt_New( void ); -extern void hb_gt_Free( void * pGtPtr ); -extern BOOL hb_gt_Resize( int iRows, int iCols ); -extern BOOL hb_gt_SetMode( int iRows, int iCols ); -extern void hb_gt_GetSize( int * piRows, int * piCols ); -extern void hb_gt_SemiCold( void ); -extern void hb_gt_ColdArea( int iTop, int iLeft, int iBottom, int iRight ); -extern void hb_gt_ExposeArea( int iTop, int iLeft, int iBottom, int iRight ); -extern void hb_gt_ScrollArea( int iTop, int iLeft, int iBottom, int iRight, BYTE bColor, BYTE bChar, int iRows, int iCols ); -extern void hb_gt_TouchCell( int iRow, int iCol ); -extern void hb_gt_Redraw( int iRow, int iCol, int iSize ); -extern void hb_gt_Refresh( void ); -extern void hb_gt_Flush( void ); -extern int hb_gt_MaxCol( void ); -extern int hb_gt_MaxRow( void ); -extern BOOL hb_gt_CheckPos( int iRow, int iCol, long *plIndex ); -extern void hb_gt_SetPos( int iRow, int iCol ); -extern void hb_gt_GetPos( int * piRow, int * piCol ); -extern BOOL hb_gt_IsColor( void ); -extern void hb_gt_GetColorStr( char * ); -extern void hb_gt_SetColorStr( const char * ); -extern void hb_gt_ColorSelect( int iColorIndex ); -extern int hb_gt_GetColor( void ); -extern int hb_gt_ColorNum( const char * ); -extern void hb_gt_ColorsToString( int *, int, char *, int ); -extern void hb_gt_StringToColors( const char *, int **, int * ); -extern void hb_gt_GetColorData( int **, int *, int * ); -extern int hb_gt_GetClearColor( void ); -extern void hb_gt_SetClearColor( int ); -extern int hb_gt_GetClearChar( void ); -extern void hb_gt_SetClearChar( int ); -extern int hb_gt_GetCursorStyle( void ); -extern void hb_gt_SetCursorStyle( int iStyle ); -extern void hb_gt_GetScrCursor( int * piRow, int * piCol, int * piStyle ); -extern BOOL hb_gt_GetScrChar( int iRow, int iCol, BYTE * pbColor, BYTE * pbAttr, USHORT * pusChar ); -extern BOOL hb_gt_PutScrChar( int iRow, int iCol, BYTE bColor, BYTE bAttr, USHORT usChar ); -extern void hb_gt_DispBegin( void ); -extern void hb_gt_DispEnd( void ); -extern int hb_gt_DispCount( void ); -extern BOOL hb_gt_GetChar( int iRow, int iCol, BYTE * pbColor, BYTE * pbAttr, USHORT * pusChar ); -extern BOOL hb_gt_PutChar( int iRow, int iCol, BYTE bColor, BYTE bAttr, USHORT usChar ); -extern long hb_gt_RectSize( int iTop, int iLeft, int iBottom, int iRight ); -extern void hb_gt_Save( int iTop, int iLeft, int iBottom, int iRight, BYTE * pBuffer ); -extern void hb_gt_Rest( int iTop, int iLeft, int iBottom, int iRight, BYTE * pBuffer ); -extern void hb_gt_PutText( int iRow, int iCol, BYTE bColor, BYTE * pText, ULONG ulLen ); -extern void hb_gt_Replicate( int iRow, int iCol, BYTE bColor, BYTE bAttr, USHORT usChar, ULONG ulLen ); -extern void hb_gt_WriteAt( int iRow, int iCol, BYTE * pText, ULONG ulLength ); -extern void hb_gt_Write( BYTE * pText, ULONG ulLength ); -extern void hb_gt_WriteCon( BYTE * pText, ULONG ulLength ); -extern void hb_gt_SetAttribute( int iTop, int iLeft, int iBottom, int iRight, BYTE bColor ); -extern void hb_gt_DrawShadow( int iTop, int iLeft, int iBottom, int iRight, BYTE bColor ); -extern void hb_gt_Scroll( int iTop, int iLeft, int iBottom, int iRight, BYTE bColor, BYTE bChar, int iRows, int iCols ); -extern void hb_gt_ScrollUp( int iRows, BYTE bColor, BYTE bChar ); -extern void hb_gt_Box( int iTop, int iLeft, int iBottom, int iRight, BYTE * pbyFrame, BYTE bColor ); -extern void hb_gt_BoxD( int iTop, int iLeft, int iBottom, int iRight, BYTE * pbyFrame, BYTE bColor ); -extern void hb_gt_BoxS( int iTop, int iLeft, int iBottom, int iRight, BYTE * pbyFrame, BYTE bColor ); -extern void hb_gt_HorizLine( int iRow, int iLeft, int iRight, BYTE bChar, BYTE bColor ); -extern void hb_gt_VertLine( int iCol, int iTop, int iBottom, BYTE bChar, BYTE bColor ); -extern BOOL hb_gt_GetBlink( void ); -extern void hb_gt_SetBlink( BOOL fBlink ); -extern void hb_gt_SetSnowFlag( BOOL fNoSnow ); -extern char * hb_gt_Version( int iType ); -extern BOOL hb_gt_Suspend( void ); -extern BOOL hb_gt_Resume( void ); -extern BOOL hb_gt_PreExt( void ); -extern BOOL hb_gt_PostExt( void ); -extern void hb_gt_OutStd( BYTE * pbyStr, ULONG ulLen ); -extern void hb_gt_OutErr( BYTE * pbyStr, ULONG ulLen ); -extern void hb_gt_Tone( double dFrequency, double dDuration ); -extern void hb_gt_Bell( void ); -extern BOOL hb_gt_Info( int iType, PHB_GT_INFO pInfo ); -extern int hb_gt_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, int iClrNorm, int iClrHigh, double dDelay ); -extern int hb_gt_SetFlag( int iType, int iNewValue ); -extern BOOL hb_gt_SetDispCP( char * pszTermCDP, char * pszHostCDP, BOOL fBox ); -extern BOOL hb_gt_SetKeyCP( char * pszTermCDP, char * pszHostCDP ); -extern int hb_gt_ReadKey( int iEventMask ); -extern int hb_inkey_Get( BOOL fWait, double dSeconds, int iEventMask ); -extern void hb_inkey_Put( int iKey ); -extern int hb_inkey_Last( int iEventMask ); -extern int hb_inkey_Next( int iEventMask ); -extern void hb_inkey_Poll( void ); -extern void hb_inkey_SetText( const char * szText, ULONG ulLen ); -extern int hb_inkey_SetLast( int iKey ); -extern void hb_inkey_Reset( void ); -extern void hb_inkey_Exit( void ); -extern void hb_mouse_Init( void ); -extern void hb_mouse_Exit( void ); -extern BOOL hb_mouse_IsPresent( void ); -extern void hb_mouse_Show( void ); -extern void hb_mouse_Hide( void ); -extern BOOL hb_mouse_GetCursor( void ); -extern void hb_mouse_SetCursor( BOOL fVisible ); -extern int hb_mouse_Col( void ); -extern int hb_mouse_Row( void ); -extern void hb_mouse_SetPos( int iRow, int iCol ); -extern void hb_mouse_GetPos( int * piRow, int * piCol ); -extern void hb_mouse_SetBounds( int iTop, int iLeft, int iBottom, int iRight ); -extern void hb_mouse_GetBounds( int * piTop, int * piLeft, int * piBottom, int * piRight ); -extern int hb_mouse_StorageSize( void ); -extern void hb_mouse_SaveState( BYTE * pBuffer ); -extern void hb_mouse_RestoreState( BYTE * pBuffer ); -extern int hb_mouse_GetDoubleClickSpeed( void ); -extern void hb_mouse_SetDoubleClickSpeed( int iSpeed ); -extern int hb_mouse_CountButton( void ); -extern BOOL hb_mouse_ButtonState( int iButton ); -extern BOOL hb_mouse_ButtonPressed( int iButton, int * piRow, int * piCol ); -extern BOOL hb_mouse_ButtonReleased( int iButton, int * piRow, int * piCol ); -extern int hb_mouse_ReadKey( int iEventMask ); -extern int hb_gt_GfxPrimitive( int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor ); -extern void hb_gt_GfxText( int iTop, int iLeft, char * szText, int iColor, int iSize, int iWidth ); -extern void hb_gt_WhoCares( void * pCargo ); +#define HB_GTLOCAL(g) (g)->pGTData[*HB_GTID_PTR] #define HB_GTSELF_INIT(g,i,o,e) (g)->pFuncTable->Init(g,i,o,e) #define HB_GTSELF_EXIT(g) (g)->pFuncTable->Exit(g) @@ -572,8 +462,8 @@ extern void hb_gt_WhoCares( void * pCargo ); #define HB_GTSELF_MOUSEISPRESENT(g) (g)->pFuncTable->MouseIsPresent(g) #define HB_GTSELF_MOUSESHOW(g) (g)->pFuncTable->MouseShow(g) #define HB_GTSELF_MOUSEHIDE(g) (g)->pFuncTable->MouseHide(g) -#define HB_GTSELF_MOUSESGETCURSOR(g) (g)->pFuncTable->MouseGetCursor(g) -#define HB_GTSELF_MOUSESSETCURSOR(g,v) (g)->pFuncTable->MouseSetCursor(g,v) +#define HB_GTSELF_MOUSEGETCURSOR(g) (g)->pFuncTable->MouseGetCursor(g) +#define HB_GTSELF_MOUSESETCURSOR(g,v) (g)->pFuncTable->MouseSetCursor(g,v) #define HB_GTSELF_MOUSECOL(g) (g)->pFuncTable->MouseCol(g) #define HB_GTSELF_MOUSEROW(g) (g)->pFuncTable->MouseRow(g) #define HB_GTSELF_MOUSEGETPOS(g,pr,pc) (g)->pFuncTable->MouseGetPos(g,pr,pc) @@ -594,119 +484,119 @@ extern void hb_gt_WhoCares( void * pCargo ); #define HB_GTSELF_GFXTEXT(g,t,l,s,c,h,w) (g)->pFuncTable->GfxText(g,t,l,s,c,h,w) #define HB_GTSELF_WHOCARES(g,p) (g)->pFuncTable->WhoCares(g,p) -#define HB_GTSUPER_INIT(i,o,e) (HB_GTSUPER)->Init(i,o,e) -#define HB_GTSUPER_EXIT() (HB_GTSUPER)->Exit() -#define HB_GTSUPER_NEW() (HB_GTSUPER)->New() -#define HB_GTSUPER_FREE(p) (HB_GTSUPER)->Free(p) -#define HB_GTSUPER_RESIZE(r,c) (HB_GTSUPER)->Resize(r,c) -#define HB_GTSUPER_SETMODE(r,c) (HB_GTSUPER)->SetMode(r,c) -#define HB_GTSUPER_GETSIZE(pr,pc) (HB_GTSUPER)->GetSize(pr,pc) -#define HB_GTSUPER_SEMICOLD() (HB_GTSUPER)->SemiCold() -#define HB_GTSUPER_COLDAREA(t,l,b,r) (HB_GTSUPER)->ColdArea(t,l,b,r) -#define HB_GTSUPER_EXPOSEAREA(t,l,b,r) (HB_GTSUPER)->ExposeArea(t,l,b,r) -#define HB_GTSUPER_SCROLLAREA(t,l,b,r,m,u,v,h) (HB_GTSUPER)->ScrollArea(t,l,b,r,m,u,v,h) -#define HB_GTSUPER_TOUCHCELL(r,c) (HB_GTSUPER)->TouchCell(r,c) -#define HB_GTSUPER_REDRAW(r,c,l) (HB_GTSUPER)->Redraw(r,c,l) -#define HB_GTSUPER_REFRESH() (HB_GTSUPER)->Refresh() -#define HB_GTSUPER_FLUSH() (HB_GTSUPER)->Flush() -#define HB_GTSUPER_MAXCOL() (HB_GTSUPER)->MaxCol() -#define HB_GTSUPER_MAXROW() (HB_GTSUPER)->MaxRow() -#define HB_GTSUPER_CHECKPOS(r,c,l) (HB_GTSUPER)->CheckPos(r,c,l) -#define HB_GTSUPER_SETPOS(r,c) (HB_GTSUPER)->SetPos(r,c) -#define HB_GTSUPER_GETPOS(pr,pc) (HB_GTSUPER)->GetPos(pr,pc) -#define HB_GTSUPER_ISCOLOR() (HB_GTSUPER)->IsColor() -#define HB_GTSUPER_GETCOLORSTR(s) (HB_GTSUPER)->GetColorStr(s) -#define HB_GTSUPER_SETCOLORSTR(s) (HB_GTSUPER)->SetColorStr(s) -#define HB_GTSUPER_COLORSELECT(c) (HB_GTSUPER)->ColorSelect(c) -#define HB_GTSUPER_GETCOLOR() (HB_GTSUPER)->GetColor() -#define HB_GTSUPER_COLORNUM(s) (HB_GTSUPER)->ColorNum(s) -#define HB_GTSUPER_COLORSTOSTRING(pc,i,ps,n) (HB_GTSUPER)->ColorsToString(pc,i,ps,n) -#define HB_GTSUPER_STRINGTOCOLORS(ps,pc,pi) (HB_GTSUPER)->StringToColors(ps,pc,pi) -#define HB_GTSUPER_GETCOLORDATA(pc,pn,pi) (HB_GTSUPER)->GetColorData(pc,pn,pi) -#define HB_GTSUPER_GETCLEARCOLOR() (HB_GTSUPER)->GetClearColor() -#define HB_GTSUPER_SETCLEARCOLOR(c) (HB_GTSUPER)->SetClearColor(c) -#define HB_GTSUPER_GETCLEARCHAR() (HB_GTSUPER)->GetClearChar() -#define HB_GTSUPER_SETCLEARCHAR(c) (HB_GTSUPER)->SetClearChar(c) -#define HB_GTSUPER_GETCURSORSTYLE() (HB_GTSUPER)->GetCursorStyle() -#define HB_GTSUPER_SETCURSORSTYLE(s) (HB_GTSUPER)->SetCursorStyle(s) -#define HB_GTSUPER_GETSCRCURSOR(pr,pc,ps) (HB_GTSUPER)->GetScrCursor(pr,pc,ps) -#define HB_GTSUPER_GETSCRCHAR(r,c,pm,pa,pc) (HB_GTSUPER)->GetScrChar(r,c,pm,pa,pc) -#define HB_GTSUPER_PUTSCRCHAR(r,c,m,a,u) (HB_GTSUPER)->PutScrChar(r,c,m,a,u) -#define HB_GTSUPER_DISPBEGIN() (HB_GTSUPER)->DispBegin() -#define HB_GTSUPER_DISPEND() (HB_GTSUPER)->DispEnd() -#define HB_GTSUPER_DISPCOUNT() (HB_GTSUPER)->DispCount() -#define HB_GTSUPER_GETCHAR(r,c,pm,pa,pc) (HB_GTSUPER)->GetChar(r,c,pm,pa,pc) -#define HB_GTSUPER_PUTCHAR(r,c,m,a,u) (HB_GTSUPER)->PutChar(r,c,m,a,u) -#define HB_GTSUPER_RECTSIZE(t,l,b,r) (HB_GTSUPER)->RectSize(t,l,b,r) -#define HB_GTSUPER_SAVE(t,l,b,r,p) (HB_GTSUPER)->Save(t,l,b,r,p) -#define HB_GTSUPER_REST(t,l,b,r,p) (HB_GTSUPER)->Rest(t,l,b,r,p) -#define HB_GTSUPER_PUTTEXT(r,c,m,s,l) (HB_GTSUPER)->PutText(r,c,m,s,l) -#define HB_GTSUPER_REPLICATE(r,c,m,a,u,l) (HB_GTSUPER)->Replicate(r,c,m,a,u,l) -#define HB_GTSUPER_WRITEAT(r,c,s,l) (HB_GTSUPER)->WriteAt(r,c,s,l) -#define HB_GTSUPER_WRITE(s,l) (HB_GTSUPER)->Write(s,l) -#define HB_GTSUPER_WRITECON(s,l) (HB_GTSUPER)->WriteCon(s,l) -#define HB_GTSUPER_SETATTRIBUTE(t,l,b,r,m) (HB_GTSUPER)->SetAttribute(t,l,b,r,m) -#define HB_GTSUPER_DRAWSHADOW(t,l,b,r,m) (HB_GTSUPER)->DrawShadow(t,l,b,r,m) -#define HB_GTSUPER_SCROLL(t,l,b,r,m,u,v,h) (HB_GTSUPER)->Scroll(t,l,b,r,m,u,v,h) -#define HB_GTSUPER_SCROLLUP(r,m,u) (HB_GTSUPER)->ScrollUp(r,m,u) -#define HB_GTSUPER_BOX(t,l,b,r,f,m) (HB_GTSUPER)->Box(t,l,b,r,f,m) -#define HB_GTSUPER_BOXD(t,l,b,r,f,m) (HB_GTSUPER)->BoxD(t,l,b,r,f,m) -#define HB_GTSUPER_BOXS(t,l,b,r,f,m) (HB_GTSUPER)->BoxS(t,l,b,r,f,m) -#define HB_GTSUPER_HORIZLINE(h,l,r,u,m) (HB_GTSUPER)->HorizLine(h,l,r,u,m) -#define HB_GTSUPER_VERTLINE(c,t,b,u,m) (HB_GTSUPER)->VertLine(c,t,b,u,m) -#define HB_GTSUPER_GETBLINK() (HB_GTSUPER)->GetBlink() -#define HB_GTSUPER_SETBLINK(b) (HB_GTSUPER)->SetBlink(b) -#define HB_GTSUPER_SETSNOWFLAG(b) (HB_GTSUPER)->SetSnowFlag(b) -#define HB_GTSUPER_VERSION(i) (HB_GTSUPER)->Version(i) -#define HB_GTSUPER_SUSPEND() (HB_GTSUPER)->Suspend() -#define HB_GTSUPER_RESUME() (HB_GTSUPER)->Resume() -#define HB_GTSUPER_PREEXT() (HB_GTSUPER)->PreExt() -#define HB_GTSUPER_POSTEXT() (HB_GTSUPER)->PostExt() -#define HB_GTSUPER_OUTSTD(s,l) (HB_GTSUPER)->OutStd(s,l) -#define HB_GTSUPER_OUTERR(s,l) (HB_GTSUPER)->OutErr(s,l) -#define HB_GTSUPER_TONE(f,d) (HB_GTSUPER)->Tone(f,d) -#define HB_GTSUPER_BELL() (HB_GTSUPER)->Bell() -#define HB_GTSUPER_INFO(i,p) (HB_GTSUPER)->Info(i,p) -#define HB_GTSUPER_ALERT(m,o,n,h,d) (HB_GTSUPER)->Alert(m,o,n,h,d) -#define HB_GTSUPER_SETFLAG(i,f) (HB_GTSUPER)->SetFlag(i,f) -#define HB_GTSUPER_SETDISPCP(t,h,b) (HB_GTSUPER)->SetDispCP(t,h,b) -#define HB_GTSUPER_SETKEYCP(t,h) (HB_GTSUPER)->SetKeyCP(t,h) -#define HB_GTSUPER_READKEY(m) (HB_GTSUPER)->ReadKey(m) -#define HB_GTSUPER_INKEYGET(w,d,m) (HB_GTSUPER)->InkeyGet(w,d,m) -#define HB_GTSUPER_INKEYPUT(k) (HB_GTSUPER)->InkeyPut(k) -#define HB_GTSUPER_INKEYLAST(m) (HB_GTSUPER)->InkeyLast(m) -#define HB_GTSUPER_INKEYNEXT(m) (HB_GTSUPER)->InkeyNext(m) -#define HB_GTSUPER_INKEYPOLL() (HB_GTSUPER)->InkeyPoll() -#define HB_GTSUPER_INKEYSETTEXT(s,l) (HB_GTSUPER)->InkeySetText(s,l) -#define HB_GTSUPER_INKEYSETLAST(k) (HB_GTSUPER)->InkeySetLast(k) -#define HB_GTSUPER_INKEYRESET() (HB_GTSUPER)->InkeyReset() -#define HB_GTSUPER_INKEYEXIT() (HB_GTSUPER)->InkeyExit() -#define HB_GTSUPER_MOUSEINIT() (HB_GTSUPER)->MouseInit() -#define HB_GTSUPER_MOUSEEXIT() (HB_GTSUPER)->MouseExit() -#define HB_GTSUPER_MOUSEISPRESENT() (HB_GTSUPER)->MouseIsPresent() -#define HB_GTSUPER_MOUSESHOW() (HB_GTSUPER)->MouseShow() -#define HB_GTSUPER_MOUSEHIDE() (HB_GTSUPER)->MouseHide() -#define HB_GTSUPER_MOUSESGETCURSOR() (HB_GTSUPER)->MouseGetCursor() -#define HB_GTSUPER_MOUSESSETCURSOR(v) (HB_GTSUPER)->MouseSetCursor(v) -#define HB_GTSUPER_MOUSECOL() (HB_GTSUPER)->MouseCol() -#define HB_GTSUPER_MOUSEROW() (HB_GTSUPER)->MouseRow() -#define HB_GTSUPER_MOUSEGETPOS(pr,pc) (HB_GTSUPER)->MouseGetPos(pr,pc) -#define HB_GTSUPER_MOUSESETPOS(r,c) (HB_GTSUPER)->MouseSetPos(r,c) -#define HB_GTSUPER_MOUSESETBOUNDS(t,l,b,r) (HB_GTSUPER)->MouseSetBounds(t,l,b,r) -#define HB_GTSUPER_MOUSEGETBOUNDS(t,l,b,r) (HB_GTSUPER)->MouseGetBounds(t,l,b,r) -#define HB_GTSUPER_MOUSESTORAGESIZE() (HB_GTSUPER)->MouseStorageSize() -#define HB_GTSUPER_MOUSESAVESTATE(p) (HB_GTSUPER)->MouseSaveState(p) -#define HB_GTSUPER_MOUSERESTORESTATE(p) (HB_GTSUPER)->MouseRestoreState(p) -#define HB_GTSUPER_MOUSEGETDOUBLECLICKSPEED() (HB_GTSUPER)->MouseGetDoubleClickSpeed() -#define HB_GTSUPER_MOUSESETDOUBLECLICKSPEED(i) (HB_GTSUPER)->MouseSetDoubleClickSpeed(i) -#define HB_GTSUPER_MOUSECOUNTBUTTON() (HB_GTSUPER)->MouseCountButton() -#define HB_GTSUPER_MOUSEBUTTONSTATE(b) (HB_GTSUPER)->MouseButtonState(b) -#define HB_GTSUPER_MOUSEBUTTONPRESSED(b,r,c) (HB_GTSUPER)->MouseButtonPressed(b,r,c) -#define HB_GTSUPER_MOUSEBUTTONRELEASED(b,r,c) (HB_GTSUPER)->MouseButtonReleased(b,r,c) -#define HB_GTSUPER_MOUSEREADKEY(m) (HB_GTSUPER)->MouseReadKey(m) -#define HB_GTSUPER_GFXPRIMITIVE(i,t,l,b,r,c) (HB_GTSUPER)->GfxPrimitive(i,t,l,b,r,c) -#define HB_GTSUPER_GFXTEXT(t,l,s,c,h,w) (HB_GTSUPER)->GfxText(t,l,s,c,h,w) -#define HB_GTSUPER_WHOCARES(p) (HB_GTSUPER)->WhoCares(p) +#define HB_GTSUPER_INIT(g,i,o,e) (HB_GTSUPER)->Init(g,i,o,e) +#define HB_GTSUPER_EXIT(g) (HB_GTSUPER)->Exit(g) +#define HB_GTSUPER_NEW(g) (HB_GTSUPER)->New(g) +#define HB_GTSUPER_FREE(g) (HB_GTSUPER)->Free(g) +#define HB_GTSUPER_RESIZE(g,r,c) (HB_GTSUPER)->Resize(g,r,c) +#define HB_GTSUPER_SETMODE(g,r,c) (HB_GTSUPER)->SetMode(g,r,c) +#define HB_GTSUPER_GETSIZE(g,pr,pc) (HB_GTSUPER)->GetSize(g,pr,pc) +#define HB_GTSUPER_SEMICOLD(g) (HB_GTSUPER)->SemiCold(g) +#define HB_GTSUPER_COLDAREA(g,t,l,b,r) (HB_GTSUPER)->ColdArea(g,t,l,b,r) +#define HB_GTSUPER_EXPOSEAREA(g,t,l,b,r) (HB_GTSUPER)->ExposeArea(g,t,l,b,r) +#define HB_GTSUPER_SCROLLAREA(g,t,l,b,r,m,u,v,h) (HB_GTSUPER)->ScrollArea(g,t,l,b,r,m,u,v,h) +#define HB_GTSUPER_TOUCHCELL(g,r,c) (HB_GTSUPER)->TouchCell(g,r,c) +#define HB_GTSUPER_REDRAW(g,r,c,l) (HB_GTSUPER)->Redraw(g,r,c,l) +#define HB_GTSUPER_REFRESH(g) (HB_GTSUPER)->Refresh(g) +#define HB_GTSUPER_FLUSH(g) (HB_GTSUPER)->Flush(g) +#define HB_GTSUPER_MAXCOL(g) (HB_GTSUPER)->MaxCol(g) +#define HB_GTSUPER_MAXROW(g) (HB_GTSUPER)->MaxRow(g) +#define HB_GTSUPER_CHECKPOS(g,r,c,l) (HB_GTSUPER)->CheckPos(g,r,c,l) +#define HB_GTSUPER_SETPOS(g,r,c) (HB_GTSUPER)->SetPos(g,r,c) +#define HB_GTSUPER_GETPOS(g,pr,pc) (HB_GTSUPER)->GetPos(g,pr,pc) +#define HB_GTSUPER_ISCOLOR(g) (HB_GTSUPER)->IsColor(g) +#define HB_GTSUPER_GETCOLORSTR(g,s) (HB_GTSUPER)->GetColorStr(g,s) +#define HB_GTSUPER_SETCOLORSTR(g,s) (HB_GTSUPER)->SetColorStr(g,s) +#define HB_GTSUPER_COLORSELECT(g,c) (HB_GTSUPER)->ColorSelect(g,c) +#define HB_GTSUPER_GETCOLOR(g) (HB_GTSUPER)->GetColor(g) +#define HB_GTSUPER_COLORNUM(g,s) (HB_GTSUPER)->ColorNum(g,s) +#define HB_GTSUPER_COLORSTOSTRING(g,pc,i,ps,n) (HB_GTSUPER)->ColorsToString(g,pc,i,ps,n) +#define HB_GTSUPER_STRINGTOCOLORS(g,ps,pc,pi) (HB_GTSUPER)->StringToColors(g,ps,pc,pi) +#define HB_GTSUPER_GETCOLORDATA(g,pc,pn,pi) (HB_GTSUPER)->GetColorData(g,pc,pn,pi) +#define HB_GTSUPER_GETCLEARCOLOR(g) (HB_GTSUPER)->GetClearColor(g) +#define HB_GTSUPER_SETCLEARCOLOR(g,c) (HB_GTSUPER)->SetClearColor(g,c) +#define HB_GTSUPER_GETCLEARCHAR(g) (HB_GTSUPER)->GetClearChar(g) +#define HB_GTSUPER_SETCLEARCHAR(g,c) (HB_GTSUPER)->SetClearChar(g,c) +#define HB_GTSUPER_GETCURSORSTYLE(g) (HB_GTSUPER)->GetCursorStyle(g) +#define HB_GTSUPER_SETCURSORSTYLE(g,s) (HB_GTSUPER)->SetCursorStyle(g,s) +#define HB_GTSUPER_GETSCRCURSOR(g,pr,pc,ps) (HB_GTSUPER)->GetScrCursor(g,pr,pc,ps) +#define HB_GTSUPER_GETSCRCHAR(g,r,c,pm,pa,pc) (HB_GTSUPER)->GetScrChar(g,r,c,pm,pa,pc) +#define HB_GTSUPER_PUTSCRCHAR(g,r,c,m,a,u) (HB_GTSUPER)->PutScrChar(g,r,c,m,a,u) +#define HB_GTSUPER_DISPBEGIN(g) (HB_GTSUPER)->DispBegin(g) +#define HB_GTSUPER_DISPEND(g) (HB_GTSUPER)->DispEnd(g) +#define HB_GTSUPER_DISPCOUNT(g) (HB_GTSUPER)->DispCount(g) +#define HB_GTSUPER_GETCHAR(g,r,c,pm,pa,pc) (HB_GTSUPER)->GetChar(g,r,c,pm,pa,pc) +#define HB_GTSUPER_PUTCHAR(g,r,c,m,a,u) (HB_GTSUPER)->PutChar(g,r,c,m,a,u) +#define HB_GTSUPER_RECTSIZE(g,t,l,b,r) (HB_GTSUPER)->RectSize(g,t,l,b,r) +#define HB_GTSUPER_SAVE(g,t,l,b,r,p) (HB_GTSUPER)->Save(g,t,l,b,r,p) +#define HB_GTSUPER_REST(g,t,l,b,r,p) (HB_GTSUPER)->Rest(g,t,l,b,r,p) +#define HB_GTSUPER_PUTTEXT(g,r,c,m,s,l) (HB_GTSUPER)->PutText(g,r,c,m,s,l) +#define HB_GTSUPER_REPLICATE(g,r,c,m,a,u,l) (HB_GTSUPER)->Replicate(g,r,c,m,a,u,l) +#define HB_GTSUPER_WRITEAT(g,r,c,s,l) (HB_GTSUPER)->WriteAt(g,r,c,s,l) +#define HB_GTSUPER_WRITE(g,s,l) (HB_GTSUPER)->Write(g,s,l) +#define HB_GTSUPER_WRITECON(g,s,l) (HB_GTSUPER)->WriteCon(g,s,l) +#define HB_GTSUPER_SETATTRIBUTE(g,t,l,b,r,m) (HB_GTSUPER)->SetAttribute(g,t,l,b,r,m) +#define HB_GTSUPER_DRAWSHADOW(g,t,l,b,r,m) (HB_GTSUPER)->DrawShadow(g,t,l,b,r,m) +#define HB_GTSUPER_SCROLL(g,t,l,b,r,m,u,v,h) (HB_GTSUPER)->Scroll(g,t,l,b,r,m,u,v,h) +#define HB_GTSUPER_SCROLLUP(g,r,m,u) (HB_GTSUPER)->ScrollUp(g,r,m,u) +#define HB_GTSUPER_BOX(g,t,l,b,r,f,m) (HB_GTSUPER)->Box(g,t,l,b,r,f,m) +#define HB_GTSUPER_BOXD(g,t,l,b,r,f,m) (HB_GTSUPER)->BoxD(g,t,l,b,r,f,m) +#define HB_GTSUPER_BOXS(g,t,l,b,r,f,m) (HB_GTSUPER)->BoxS(g,t,l,b,r,f,m) +#define HB_GTSUPER_HORIZLINE(g,h,l,r,u,m) (HB_GTSUPER)->HorizLine(g,h,l,r,u,m) +#define HB_GTSUPER_VERTLINE(g,c,t,b,u,m) (HB_GTSUPER)->VertLine(g,c,t,b,u,m) +#define HB_GTSUPER_GETBLINK(g) (HB_GTSUPER)->GetBlink(g) +#define HB_GTSUPER_SETBLINK(g,b) (HB_GTSUPER)->SetBlink(g,b) +#define HB_GTSUPER_SETSNOWFLAG(g,b) (HB_GTSUPER)->SetSnowFlag(g,b) +#define HB_GTSUPER_VERSION(g,i) (HB_GTSUPER)->Version(g,i) +#define HB_GTSUPER_SUSPEND(g) (HB_GTSUPER)->Suspend(g) +#define HB_GTSUPER_RESUME(g) (HB_GTSUPER)->Resume(g) +#define HB_GTSUPER_PREEXT(g) (HB_GTSUPER)->PreExt(g) +#define HB_GTSUPER_POSTEXT(g) (HB_GTSUPER)->PostExt(g) +#define HB_GTSUPER_OUTSTD(g,s,l) (HB_GTSUPER)->OutStd(g,s,l) +#define HB_GTSUPER_OUTERR(g,s,l) (HB_GTSUPER)->OutErr(g,s,l) +#define HB_GTSUPER_TONE(g,f,d) (HB_GTSUPER)->Tone(g,f,d) +#define HB_GTSUPER_BELL(g) (HB_GTSUPER)->Bell(g) +#define HB_GTSUPER_INFO(g,i,p) (HB_GTSUPER)->Info(g,i,p) +#define HB_GTSUPER_ALERT(g,m,o,n,h,d) (HB_GTSUPER)->Alert(g,m,o,n,h,d) +#define HB_GTSUPER_SETFLAG(g,i,f) (HB_GTSUPER)->SetFlag(g,i,f) +#define HB_GTSUPER_SETDISPCP(g,t,h,b) (HB_GTSUPER)->SetDispCP(g,t,h,b) +#define HB_GTSUPER_SETKEYCP(g,t,h) (HB_GTSUPER)->SetKeyCP(g,t,h) +#define HB_GTSUPER_READKEY(g,m) (HB_GTSUPER)->ReadKey(g,m) +#define HB_GTSUPER_INKEYGET(g,w,d,m) (HB_GTSUPER)->InkeyGet(g,w,d,m) +#define HB_GTSUPER_INKEYPUT(g,k) (HB_GTSUPER)->InkeyPut(g,k) +#define HB_GTSUPER_INKEYLAST(g,m) (HB_GTSUPER)->InkeyLast(g,m) +#define HB_GTSUPER_INKEYNEXT(g,m) (HB_GTSUPER)->InkeyNext(g,m) +#define HB_GTSUPER_INKEYPOLL(g) (HB_GTSUPER)->InkeyPoll(g) +#define HB_GTSUPER_INKEYSETTEXT(g,s,l) (HB_GTSUPER)->InkeySetText(g,s,l) +#define HB_GTSUPER_INKEYSETLAST(g,k) (HB_GTSUPER)->InkeySetLast(g,k) +#define HB_GTSUPER_INKEYRESET(g) (HB_GTSUPER)->InkeyReset(g) +#define HB_GTSUPER_INKEYEXIT(g) (HB_GTSUPER)->InkeyExit(g) +#define HB_GTSUPER_MOUSEINIT(g) (HB_GTSUPER)->MouseInit(g) +#define HB_GTSUPER_MOUSEEXIT(g) (HB_GTSUPER)->MouseExit(g) +#define HB_GTSUPER_MOUSEISPRESENT(g) (HB_GTSUPER)->MouseIsPresent(g) +#define HB_GTSUPER_MOUSESHOW(g) (HB_GTSUPER)->MouseShow(g) +#define HB_GTSUPER_MOUSEHIDE(g) (HB_GTSUPER)->MouseHide(g) +#define HB_GTSUPER_MOUSEGETCURSOR(g) (HB_GTSUPER)->MouseGetCursor(g) +#define HB_GTSUPER_MOUSESETCURSOR(g,v) (HB_GTSUPER)->MouseSetCursor(g,v) +#define HB_GTSUPER_MOUSECOL(g) (HB_GTSUPER)->MouseCol(g) +#define HB_GTSUPER_MOUSEROW(g) (HB_GTSUPER)->MouseRow(g) +#define HB_GTSUPER_MOUSEGETPOS(g,pr,pc) (HB_GTSUPER)->MouseGetPos(g,pr,pc) +#define HB_GTSUPER_MOUSESETPOS(g,r,c) (HB_GTSUPER)->MouseSetPos(g,r,c) +#define HB_GTSUPER_MOUSESETBOUNDS(g,t,l,b,r) (HB_GTSUPER)->MouseSetBounds(g,t,l,b,r) +#define HB_GTSUPER_MOUSEGETBOUNDS(g,t,l,b,r) (HB_GTSUPER)->MouseGetBounds(g,t,l,b,r) +#define HB_GTSUPER_MOUSESTORAGESIZE(g) (HB_GTSUPER)->MouseStorageSize(g) +#define HB_GTSUPER_MOUSESAVESTATE(g,p) (HB_GTSUPER)->MouseSaveState(g,p) +#define HB_GTSUPER_MOUSERESTORESTATE(g,p) (HB_GTSUPER)->MouseRestoreState(g,p) +#define HB_GTSUPER_MOUSEGETDOUBLECLICKSPEED(g) (HB_GTSUPER)->MouseGetDoubleClickSpeed(g) +#define HB_GTSUPER_MOUSESETDOUBLECLICKSPEED(g,i) (HB_GTSUPER)->MouseSetDoubleClickSpeed(g,i) +#define HB_GTSUPER_MOUSECOUNTBUTTON(g) (HB_GTSUPER)->MouseCountButton(g) +#define HB_GTSUPER_MOUSEBUTTONSTATE(g,b) (HB_GTSUPER)->MouseButtonState(g,b) +#define HB_GTSUPER_MOUSEBUTTONPRESSED(g,b,r,c) (HB_GTSUPER)->MouseButtonPressed(g,b,r,c) +#define HB_GTSUPER_MOUSEBUTTONRELEASED(g,b,r,c) (HB_GTSUPER)->MouseButtonReleased(g,b,r,c) +#define HB_GTSUPER_MOUSEREADKEY(g,m) (HB_GTSUPER)->MouseReadKey(g,m) +#define HB_GTSUPER_GFXPRIMITIVE(g,i,t,l,b,r,c) (HB_GTSUPER)->GfxPrimitive(g,i,t,l,b,r,c) +#define HB_GTSUPER_GFXTEXT(g,t,l,s,c,h,w) (HB_GTSUPER)->GfxText(g,t,l,s,c,h,w) +#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 ); diff --git a/harbour/source/rtl/gtalleg/gtalleg.c b/harbour/source/rtl/gtalleg/gtalleg.c index ae16302b72..faae5adf34 100644 --- a/harbour/source/rtl/gtalleg/gtalleg.c +++ b/harbour/source/rtl/gtalleg/gtalleg.c @@ -181,7 +181,7 @@ static const gtAllegKey sCtrlTable[GT_CTRL_TABLE_SIZE] = { if( r > s_iGFXUpdRight ) s_iGFXUpdRight=r; \ } while(0) #define GT_SCREENINIT() do { if( !s_fInit ) \ - hb_gt_alleg_InitializeScreen( s_iScrHeight, s_iScrWidth, TRUE ); \ + hb_gt_alleg_InitializeScreen( pGT, s_iScrHeight, s_iScrWidth, TRUE ); \ } while( 0 ) #define MK_GT8BCOLOR(n) ((n & 0xFF) / 16 | (n & 0xFF00) / 256) @@ -258,14 +258,14 @@ static void hb_gt_alleg_DoCursor( int iRow, int iCol, int iStyle ) s_iCursorStyle = iStyle; } -static void hb_gt_alleg_ScreenUpdate( void ) +static void hb_gt_alleg_ScreenUpdate( PHB_GT pGT ) { int iRow, iCol, iStyle; BOOL fPix, fCursor; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_ScreenUpdate()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_ScreenUpdate(%p)", pGT)); - hb_gt_GetScrCursor( &iRow, &iCol, &iStyle ); + HB_GTSELF_GETSCRCURSOR( pGT, &iRow, &iCol, &iStyle ); fPix = s_iGFXUpdTop <= s_iGFXUpdBottom && s_iGFXUpdLeft <= s_iGFXUpdRight; fCursor = s_iCurRow != iRow || s_iCurCol != iCol || s_iCursorStyle != iStyle; @@ -292,14 +292,14 @@ static void hb_gt_alleg_ScreenUpdate( void ) } } -static BOOL hb_gt_alleg_InitializeScreen( int iRows, int iCols, BOOL lClearInit ) +static BOOL hb_gt_alleg_InitializeScreen( PHB_GT pGT, int iRows, int iCols, BOOL lClearInit ) { PHB_FNAME pFileName; int iRet = 1, iWidth, iHeight; /* Don't remove iRet, ixFP and iyFP initializers! */ short ixFP = 0, iyFP = 0; BOOL lMode = FALSE, lPrev = s_fInit; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_InitializeScreen(%d, %d, %d)", iRows, iCols, (int) lClearInit )); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_InitializeScreen(%p,%d,%d,%d)", pGT, iRows, iCols, (int) lClearInit )); if( s_fGtError ) { @@ -499,14 +499,14 @@ static BOOL hb_gt_alleg_InitializeScreen( int iRows, int iCols, BOOL lClearInit if( !lClearInit ) { - BYTE bColor = s_pClr[ ( hb_gt_GetClearColor() >> 4 ) & 0x0f ]; + BYTE bColor = s_pClr[ ( HB_GTSELF_GETCLEARCOLOR( pGT ) >> 4 ) & 0x0f ]; al_clear_to_color( bmp, bColor ); al_clear_to_color( al_screen, bColor ); } - HB_GTSUPER_RESIZE( s_iScrHeight, s_iScrWidth ); - hb_gt_ExposeArea( 0, 0, s_iScrHeight, s_iScrWidth ); - hb_gt_Refresh(); + HB_GTSUPER_RESIZE( pGT, s_iScrHeight, s_iScrWidth ); + HB_GTSELF_EXPOSEAREA( pGT, 0, 0, s_iScrHeight, s_iScrWidth ); + HB_GTSELF_REFRESH( pGT ); } s_iGFXWidth = 0; @@ -515,11 +515,11 @@ static BOOL hb_gt_alleg_InitializeScreen( int iRows, int iCols, BOOL lClearInit return lMode; } -static void hb_gt_alleg_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) +static void hb_gt_alleg_Init( PHB_GT pGT, FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) { int iRet; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_Init(%p,%p,%p)", hFilenoStdin, hFilenoStdout, hFilenoStderr)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_Init(%p,%p,%p,%p)", pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr)); ssfCreateThinFont( &s_ssfDefaultFont ); @@ -538,15 +538,15 @@ static void hb_gt_alleg_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHAND al_set_color_depth( iRet ); } - HB_GTSUPER_INIT( hFilenoStdin, hFilenoStdout, hFilenoStderr ); - HB_GTSUPER_RESIZE( s_iScrHeight, s_iScrWidth ); + HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr ); + HB_GTSUPER_RESIZE( pGT, s_iScrHeight, s_iScrWidth ); } -static void hb_gt_alleg_Exit( void ) +static void hb_gt_alleg_Exit( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_Exit()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_Exit(%p)", pGT)); - HB_GTSUPER_EXIT(); + HB_GTSUPER_EXIT( pGT ); if( bmp ) { @@ -555,27 +555,31 @@ static void hb_gt_alleg_Exit( void ) } } -static char * hb_gt_alleg_Version( int iType ) +static char * hb_gt_alleg_Version( PHB_GT pGT, int iType ) { + HB_SYMBOL_UNUSED( pGT ); + if( iType == 0 ) return HB_GT_DRVNAME( HB_GT_NAME ); return "Harbour Terminal: Multiplatform Allegro graphics console"; } -static BOOL hb_gt_alleg_SetMode( int iRows, int iCols ) +static BOOL hb_gt_alleg_SetMode( PHB_GT pGT, int iRows, int iCols ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_SetMode(%d, %d)", iRows, iCols)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_SetMode(%p,%d,%d)", pGT, iRows, iCols)); - return hb_gt_alleg_InitializeScreen( iRows, iCols, TRUE ); + HB_SYMBOL_UNUSED( pGT ); + + return hb_gt_alleg_InitializeScreen( pGT, iRows, iCols, TRUE ); } -static int hb_gt_alleg_ReadKey( int iEventMask ) +static int hb_gt_alleg_ReadKey( PHB_GT pGT, int iEventMask ) { int nKey = 0; int i, iMSX, iMSY; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_ReadKey(%d)", iEventMask)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_ReadKey(%p,%d)", pGT, iEventMask)); GT_SCREENINIT(); @@ -724,12 +728,14 @@ static int hb_gt_alleg_ReadKey( int iEventMask ) return nKey; } -static BOOL hb_gt_alleg_mouse_IsPresent( void ) +static BOOL hb_gt_alleg_mouse_IsPresent( PHB_GT pGT ) { + HB_SYMBOL_UNUSED( pGT ); + return TRUE; } -static void hb_gt_alleg_mouse_GetPos( int * piRow, int * piCol ) +static void hb_gt_alleg_mouse_GetPos( PHB_GT pGT, int * piRow, int * piCol ) { GT_SCREENINIT(); @@ -742,14 +748,14 @@ static void hb_gt_alleg_mouse_GetPos( int * piRow, int * piCol ) *piCol = al_mouse_x / s_byFontWidth; } -static void hb_gt_alleg_mouse_SetPos( int iRow, int iCol ) +static void hb_gt_alleg_mouse_SetPos( PHB_GT pGT, int iRow, int iCol ) { GT_SCREENINIT(); al_position_mouse(iCol * s_byFontWidth, iRow * s_byFontSize); } -static BOOL hb_gt_alleg_mouse_ButtonState( int iButton ) +static BOOL hb_gt_alleg_mouse_ButtonState( PHB_GT pGT, int iButton ) { GT_SCREENINIT(); @@ -761,14 +767,14 @@ static BOOL hb_gt_alleg_mouse_ButtonState( int iButton ) return ( al_mouse_b & ( 1 << ( iButton - 1 ) ) ) != 0; } -static int hb_gt_alleg_mouse_CountButton( void ) +static int hb_gt_alleg_mouse_CountButton( PHB_GT pGT ) { GT_SCREENINIT(); return s_iMsButtons; } -static void hb_gt_alleg_mouse_SetBounds( int iTop, int iLeft, int iBottom, int iRight ) +static void hb_gt_alleg_mouse_SetBounds( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight ) { GT_SCREENINIT(); @@ -795,7 +801,7 @@ static void hb_gt_alleg_mouse_SetBounds( int iTop, int iLeft, int iBottom, int i al_set_mouse_range( s_iMSBoundLeft, s_iMSBoundTop, s_iMSBoundRight, s_iMSBoundBottom ); } -static void hb_gt_alleg_mouse_GetBounds( int *piTop, int *piLeft, int *piBottom, int *piRight ) +static void hb_gt_alleg_mouse_GetBounds( PHB_GT pGT, int *piTop, int *piLeft, int *piBottom, int *piRight ) { GT_SCREENINIT(); @@ -805,11 +811,11 @@ static void hb_gt_alleg_mouse_GetBounds( int *piTop, int *piLeft, int *piBottom, *piRight = s_iMSBoundRight; } -static BOOL hb_gt_alleg_Info( int iType, PHB_GT_INFO pInfo ) +static BOOL hb_gt_alleg_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) { int iWidth, iHeight, iValue; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_Info(%d, %p)", iType, pInfo)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_Info(%p,%d,%p)", pGT, iType, pInfo)); switch( iType ) { @@ -830,7 +836,7 @@ static BOOL hb_gt_alleg_Info( int iType, PHB_GT_INFO pInfo ) if( iWidth > 0 ) { s_iGFXWidth = iWidth; - /* hb_gt_alleg_InitializeScreen(s_iScrHeight, s_iScrWidth, s_fInit); */ + /* hb_gt_alleg_InitializeScreen( pGT, s_iScrHeight, s_iScrWidth, s_fInit ); */ } break; @@ -841,7 +847,7 @@ static BOOL hb_gt_alleg_Info( int iType, PHB_GT_INFO pInfo ) if( iHeight > 0 ) { s_iGFXHeight = iHeight; - hb_gt_alleg_InitializeScreen(s_iScrHeight, s_iScrWidth, s_fInit); + hb_gt_alleg_InitializeScreen( pGT, s_iScrHeight, s_iScrWidth, s_fInit ); } break; @@ -853,7 +859,7 @@ static BOOL hb_gt_alleg_Info( int iType, PHB_GT_INFO pInfo ) iValue == 24 || iValue == 32 ) { al_set_color_depth( iValue ); - hb_gt_alleg_InitializeScreen(s_iScrHeight, s_iScrWidth, s_fInit); + hb_gt_alleg_InitializeScreen( pGT, s_iScrHeight, s_iScrWidth, s_fInit ); } break; @@ -864,7 +870,7 @@ static BOOL hb_gt_alleg_Info( int iType, PHB_GT_INFO pInfo ) { s_byFontSize = ( BYTE ) iValue; s_byFontWidth = s_byFontSize / 2; - hb_gt_alleg_InitializeScreen(s_iScrHeight, s_iScrWidth, s_fInit); + hb_gt_alleg_InitializeScreen( pGT, s_iScrHeight, s_iScrWidth, s_fInit ); } break; @@ -914,7 +920,7 @@ static BOOL hb_gt_alleg_Info( int iType, PHB_GT_INFO pInfo ) break; default: - return HB_GTSUPER_INFO( iType, pInfo ); + return HB_GTSUPER_INFO( pGT, iType, pInfo ); } return TRUE; @@ -922,14 +928,14 @@ static BOOL hb_gt_alleg_Info( int iType, PHB_GT_INFO pInfo ) /* ********** Graphics API ********** */ -static int hb_gt_alleg_gfx_Primitive( int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor ) +static int hb_gt_alleg_gfx_Primitive( PHB_GT pGT, int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor ) { int iRet = 1; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_gfx_Primitive(%d, %d, %d, %d, %d, %d)", iType, iTop, iLeft, iBottom, iRight, iColor)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_gfx_Primitive(%p,%d,%d,%d,%d,%d,%d)", pGT, iType, iTop, iLeft, iBottom, iRight, iColor)); GT_SCREENINIT(); - hb_gt_Refresh(); + HB_GTSELF_REFRESH( pGT ); switch( iType ) { @@ -1046,27 +1052,27 @@ static int hb_gt_alleg_gfx_Primitive( int iType, int iTop, int iLeft, int iBotto break; default: - return HB_GTSUPER_GFXPRIMITIVE( iType, iTop, iLeft, iBottom, iRight, iColor ); + return HB_GTSUPER_GFXPRIMITIVE( pGT, iType, iTop, iLeft, iBottom, iRight, iColor ); } - if( hb_gt_DispCount() == 0 ) + if( HB_GTSELF_DISPCOUNT( pGT ) == 0 ) { - hb_gt_alleg_ScreenUpdate(); + hb_gt_alleg_ScreenUpdate( pGT ); } return iRet; } -static void hb_gt_alleg_gfx_Text( int iTop, int iLeft, char * cBuf, int iColor, int iSize, int iWidth ) +static void hb_gt_alleg_gfx_Text( PHB_GT pGT, int iTop, int iLeft, char * cBuf, int iColor, int iSize, int iWidth ) { int iBottom, iRight; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_gfx_Text(%d, %d, %s, %d, %d, %d)", iTop, iLeft, cBuf, iColor, iSize, iWidth)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_alleg_gfx_Text(%p,%d,%d,%s,%d,%d,%d)", pGT, iTop, iLeft, cBuf, iColor, iSize, iWidth)); HB_SYMBOL_UNUSED( iWidth ); GT_SCREENINIT(); - hb_gt_Refresh(); + HB_GTSELF_REFRESH( pGT ); if( iSize ) { @@ -1086,20 +1092,20 @@ static void hb_gt_alleg_gfx_Text( int iTop, int iLeft, char * cBuf, int iColor, ssfSetFontSize( &s_ssfDefaultFont, s_byFontSize ); } - if( hb_gt_DispCount() == 0 ) + if( HB_GTSELF_DISPCOUNT( pGT ) == 0 ) { - hb_gt_alleg_ScreenUpdate(); + hb_gt_alleg_ScreenUpdate( pGT ); } } /* ******** Graphics API end ******** */ -static void hb_gt_alleg_Redraw( int iRow, int iCol, int iSize ) +static void hb_gt_alleg_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize ) { BYTE bColor, bAttr; USHORT usChar; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_alleg_Redraw(%d, %d, %d)", iRow, iCol, iSize ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_alleg_Redraw(%p,%d,%d,%d)", pGT, iRow, iCol, iSize ) ); if( s_fInit ) { @@ -1114,7 +1120,7 @@ static void hb_gt_alleg_Redraw( int iRow, int iCol, int iSize ) while( iSize-- ) { - if( !hb_gt_GetScrChar( iRow, iCol++, &bColor, &bAttr, &usChar ) ) + 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] ); @@ -1123,11 +1129,11 @@ static void hb_gt_alleg_Redraw( int iRow, int iCol, int iSize ) } else if( !s_fMakeInit ) { - BYTE bDefColor = hb_gt_GetColor(); + BYTE bDefColor = HB_GTSELF_GETCOLOR( pGT ); while( iSize-- ) { - if( !hb_gt_GetScrChar( iRow, iCol++, &bColor, &bAttr, &usChar ) ) + if( !HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol++, &bColor, &bAttr, &usChar ) ) break; if( bColor != bDefColor || usChar != ' ' ) @@ -1139,25 +1145,25 @@ static void hb_gt_alleg_Redraw( int iRow, int iCol, int iSize ) } } -static void hb_gt_alleg_Refresh( void ) +static void hb_gt_alleg_Refresh( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_alleg_Refresh()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_alleg_Refresh(%p)", pGT ) ); if( !s_fGtError ) { if( s_fInit ) { al_acquire_bitmap(bmp); - HB_GTSUPER_REFRESH(); + HB_GTSUPER_REFRESH( pGT ); al_release_bitmap(bmp); - if( hb_gt_DispCount() == 0 ) + if( HB_GTSELF_DISPCOUNT( pGT ) == 0 ) { - hb_gt_alleg_ScreenUpdate(); + hb_gt_alleg_ScreenUpdate( pGT ); } } else { - HB_GTSUPER_REFRESH(); + HB_GTSUPER_REFRESH( pGT ); if( s_fMakeInit ) { s_fMakeInit = FALSE; diff --git a/harbour/source/rtl/gtapi.c b/harbour/source/rtl/gtapi.c index ae22905bb3..86505d025e 100644 --- a/harbour/source/rtl/gtapi.c +++ b/harbour/source/rtl/gtapi.c @@ -81,25 +81,35 @@ #include "hbgtcore.h" #include "hbset.h" +#define HB_STDOUT_HANDLE 1 +#define HB_STDERR_HANDLE 2 + static BOOL s_bInit = FALSE; /* gt API functions */ HB_EXPORT ERRCODE hb_gtInit( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtInit()")); hb_gtStartupInit(); - hb_gt_Init( hFilenoStdin, hFilenoStdout, hFilenoStderr ); - hb_gt_SetColorStr( hb_set.HB_SET_COLOR ); - hb_gt_SetCursorStyle( SC_NORMAL ); - s_bInit = TRUE; - hb_gt_Flush(); + pGT = hb_gt_Base(); + if( pGT ) + { + s_bInit = TRUE; + HB_GTSELF_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr ); + HB_GTSELF_SETCOLORSTR( pGT, hb_set.HB_SET_COLOR ); + HB_GTSELF_SETCURSORSTYLE( pGT, SC_NORMAL ); + HB_GTSELF_FLUSH( pGT ); + } if( hb_cmdargCheck( "INFO" ) ) { - hb_conOutErr( hb_gt_Version( 1 ), 0 ); + if( pGT ) + hb_conOutErr( HB_GTSELF_VERSION( pGT, 1 ), 0 ); hb_conOutErr( hb_conNewLine(), 0 ); } @@ -112,12 +122,16 @@ HB_EXPORT ERRCODE hb_gtExit( void ) if( s_bInit ) { - while( hb_gt_DispCount() ) - hb_gt_DispEnd(); + PHB_GT pGT = hb_gt_Base(); - hb_gt_Flush(); - hb_gt_Exit(); + if( pGT ) + { + while( HB_GTSELF_DISPCOUNT( pGT ) ) + HB_GTSELF_DISPEND( pGT ); + HB_GTSELF_FLUSH( pGT ); + HB_GTSELF_EXIT( pGT ); + } s_bInit = FALSE; hb_gtUnLoad(); @@ -128,95 +142,154 @@ HB_EXPORT ERRCODE hb_gtExit( void ) HB_EXPORT int hb_gtReadKey( int iEventMask ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtReadKey(%d)", iEventMask)); - return hb_gt_ReadKey( iEventMask ); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_READKEY( pGT, iEventMask ) : 0; } HB_EXPORT ERRCODE hb_gtBox( SHORT Top, SHORT Left, SHORT Bottom, SHORT Right, BYTE * pbyFrame ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtBox(%hd, %hd, %hd, %hd, %p)", Top, Left, Bottom, Right, pbyFrame)); - hb_gt_Box( Top, Left, Bottom, Right, pbyFrame, ( BYTE ) hb_gt_GetColor() ); - hb_gt_SetPos( Top + 1, Left + 1 ); - hb_gt_Flush(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_BOX( pGT, Top, Left, Bottom, Right, pbyFrame, HB_GTSELF_GETCOLOR( pGT ) ); + HB_GTSELF_SETPOS( pGT, Top + 1, Left + 1 ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtBoxD( SHORT Top, SHORT Left, SHORT Bottom, SHORT Right ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtBoxD(%hd, %hd, %hd, %hd)", Top, Left, Bottom, Right)); - hb_gt_Box( Top, Left, Bottom, Right, ( BYTE * ) _B_DOUBLE, ( BYTE ) hb_gt_GetColor() ); - hb_gt_SetPos( Top + 1, Left + 1 ); - hb_gt_Flush(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_BOXD( pGT, Top, Left, Bottom, Right, ( BYTE * ) _B_DOUBLE, HB_GTSELF_GETCOLOR( pGT ) ); + HB_GTSELF_SETPOS( pGT, Top + 1, Left + 1 ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtBoxS( SHORT Top, SHORT Left, SHORT Bottom, SHORT Right ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtBoxS(%hd, %hd, %hd, %hd)", Top, Left, Bottom, Right)); - hb_gt_Box( Top, Left, Bottom, Right, ( BYTE * ) _B_SINGLE, ( BYTE ) hb_gt_GetColor() ); - hb_gt_SetPos( Top + 1, Left + 1 ); - hb_gt_Flush(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_BOXD( pGT, Top, Left, Bottom, Right, ( BYTE * ) _B_SINGLE, HB_GTSELF_GETCOLOR( pGT ) ); + HB_GTSELF_SETPOS( pGT, Top + 1, Left + 1 ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtColorSelect( USHORT uiColorIndex ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtColorSelect(%hu)", uiColorIndex)); - hb_gt_ColorSelect( uiColorIndex ); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_COLORSELECT( pGT, uiColorIndex ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtDispBegin( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtDispBegin()")); - hb_gt_DispBegin(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_DISPBEGIN( pGT ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT USHORT hb_gtDispCount( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtDispCount()")); - return hb_gt_DispCount(); + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_DISPCOUNT( pGT ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtDispEnd( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtDispEnd()")); - hb_gt_DispEnd(); - hb_gt_Flush(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_DISPEND( pGT ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtPreExt( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtPreExt()")); - hb_gt_PreExt(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + if( HB_GTSELF_PREEXT( pGT ) ) + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtPostExt( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtPostExt()")); - hb_gt_PostExt(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + if( HB_GTSELF_POSTEXT( pGT ) ) + return SUCCESS; + } + return FAILURE; } /* NOTE: szColorString must be at least CLR_STRLEN wide by the NG. It seems @@ -226,44 +299,74 @@ HB_EXPORT ERRCODE hb_gtPostExt( void ) HB_EXPORT ERRCODE hb_gtGetColorStr( char * pszColorString ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtGetColorStr(%s)", pszColorString)); - hb_gt_GetColorStr( pszColorString ); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_GETCOLORSTR( pGT, pszColorString ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT USHORT hb_gtColorToN( char * szColorString ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtColorToN(%s)", szColorString)); - return hb_gt_ColorNum( szColorString ); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_COLORNUM( pGT, szColorString ) : 0; } HB_EXPORT USHORT hb_gtColorsToString( int * pColors, int iColorCount, char * pszColorString, int iBufSize ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtColorsToString(%p, %d, %p, %d)", pColors, iColorCount, pszColorString, iBufSize)); - hb_gt_ColorsToString( pColors, iColorCount, pszColorString, iBufSize ); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_COLORSTOSTRING( pGT, pColors, iColorCount, pszColorString, iBufSize ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtSetColorStr( const char * szColorString ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtSetColorStr(%s)", szColorString)); - hb_gt_SetColorStr( szColorString ); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_SETCOLORSTR( pGT, szColorString ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtGetCursor( USHORT * uipCursorStyle ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtGetCursor(%p)", uipCursorStyle)); - *uipCursorStyle = hb_gt_GetCursorStyle(); - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + *uipCursorStyle = HB_GTSELF_GETCURSORSTYLE( pGT ); + return SUCCESS; + } + + *uipCursorStyle = SC_NONE; + return FAILURE; } HB_EXPORT ERRCODE hb_gtSetCursor( USHORT uiCursorStyle ) @@ -272,10 +375,13 @@ HB_EXPORT ERRCODE hb_gtSetCursor( USHORT uiCursorStyle ) if( uiCursorStyle <= SC_SPECIAL2 ) { - hb_gt_SetCursorStyle( uiCursorStyle ); - hb_gt_Flush(); - - return SUCCESS; + PHB_GT pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_SETCURSORSTYLE( pGT, uiCursorStyle ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } } return FAILURE; @@ -283,15 +389,22 @@ HB_EXPORT ERRCODE hb_gtSetCursor( USHORT uiCursorStyle ) HB_EXPORT ERRCODE hb_gtGetPos( SHORT * piRow, SHORT * piCol ) { - int iRow, iCol; + PHB_GT pGT; HB_TRACE(HB_TR_DEBUG, ("hb_gtGetPos(%p, %p)", piRow, piCol)); - hb_gt_GetPos( &iRow, &iCol ); - *piRow = ( SHORT ) iRow; - *piCol = ( SHORT ) iCol; + pGT = hb_gt_Base(); + if( pGT ) + { + int iRow, iCol; - return SUCCESS; + HB_GTSELF_GETPOS( pGT, &iRow, &iCol ); + *piRow = ( SHORT ) iRow; + *piCol = ( SHORT ) iCol; + + return SUCCESS; + } + return FAILURE; } /* NOTE: Should be exactly the same as hb_gtSetPosContext(), but without the @@ -299,110 +412,175 @@ HB_EXPORT ERRCODE hb_gtGetPos( SHORT * piRow, SHORT * piCol ) HB_EXPORT ERRCODE hb_gtSetPos( SHORT iRow, SHORT iCol ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtSetPos(%hd, %hd)", iRow, iCol)); - hb_gt_SetPos( iRow, iCol ); - hb_gt_Flush(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_SETPOS( pGT, iRow, iCol ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT USHORT hb_gtMaxCol( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtMaxCol()")); - return hb_gt_MaxCol(); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_MAXCOL( pGT ) : 79; } HB_EXPORT USHORT hb_gtMaxRow( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtMaxRow()")); - return hb_gt_MaxRow(); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_MAXROW( pGT ) : 24; } HB_EXPORT ERRCODE hb_gtScrDim( USHORT * uipHeight, USHORT * uipWidth ) { - int iHeight, iWidth; + PHB_GT pGT; HB_TRACE(HB_TR_DEBUG, ("hb_gtScrDim(%p, %p)", uipHeight, uipWidth)); - hb_gt_GetSize( &iHeight, &iWidth ); - *uipHeight = ( USHORT ) iHeight; - *uipWidth = ( USHORT ) iWidth; + pGT = hb_gt_Base(); + if( pGT ) + { + int iHeight, iWidth; - return SUCCESS; + HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth ); + *uipHeight = ( USHORT ) iHeight; + *uipWidth = ( USHORT ) iWidth; + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtSetSnowFlag( BOOL fNoSnow ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtSetSnowFlag(%d)", (int) fNoSnow)); - hb_gt_SetSnowFlag( fNoSnow ); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_SETSNOWFLAG( pGT, fNoSnow ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtRectSize( int iTop, int iLeft, int iBottom, int iRight, ULONG * pulBuffSize ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtRectSize(%d, %d, %d, %d, %p)", iTop, iLeft, iBottom, iRight, pulBuffSize)); - *pulBuffSize = hb_gt_RectSize( iTop, iLeft, iBottom, iRight ); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + *pulBuffSize = HB_GTSELF_RECTSIZE( pGT, iTop, iLeft, iBottom, iRight ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT BOOL hb_gtIsColor( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtIsColor()")); - return hb_gt_IsColor(); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_ISCOLOR( pGT ) : TRUE; } HB_EXPORT ERRCODE hb_gtRepChar( USHORT uiRow, USHORT uiCol, BYTE byChar, USHORT uiCount ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtRepChar(%hu, %hu, %d, %hu)", uiRow, uiCol, (int) byChar, uiCount)); - hb_gt_Replicate( uiRow, uiCol, ( BYTE ) hb_gt_GetColor(), 0, - byChar, uiCount ); - hb_gt_Flush(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_REPLICATE( pGT, uiRow, uiCol, HB_GTSELF_GETCOLOR( pGT ), 0, + byChar, uiCount ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtSave( USHORT uiTop, USHORT uiLeft, USHORT uiBottom, USHORT uiRight, void * pScrBuff ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtSave(%hu, %hu, %hu, %hu, %p)", uiTop, uiLeft, uiBottom, uiRight, pScrBuff)); - hb_gt_Save( uiTop, uiLeft, uiBottom, uiRight, ( BYTE * ) pScrBuff ); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_SAVE( pGT, uiTop, uiLeft, uiBottom, uiRight, ( BYTE * ) pScrBuff ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtRest( USHORT uiTop, USHORT uiLeft, USHORT uiBottom, USHORT uiRight, void * pScrBuff ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtRest(%hu, %hu, %hu, %hu, %p)", uiTop, uiLeft, uiBottom, uiRight, pScrBuff)); - hb_gt_Rest( uiTop, uiLeft, uiBottom, uiRight, ( BYTE * ) pScrBuff ); - hb_gt_Flush(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_REST( pGT, uiTop, uiLeft, uiBottom, uiRight, ( BYTE * ) pScrBuff ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtGetChar( USHORT uiRow, USHORT uiCol, BYTE * pbColor, BYTE * pbAttr, USHORT * pusChar ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtGetChar(%hu, %hu, %p, %p, %p)", uiRow, uiCol, pbColor, pbAttr, pusChar)); - return hb_gt_GetChar( uiRow, uiCol, pbColor, pbAttr, pusChar ) ? - SUCCESS : FAILURE; + pGT = hb_gt_Base(); + if( pGT ) + { + if( HB_GTSELF_GETCHAR( pGT, uiRow, uiCol, pbColor, pbAttr, pusChar ) ) + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtPutChar( USHORT uiRow, USHORT uiCol, BYTE bColor, BYTE bAttr, USHORT usChar ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtPutChar(%hu, %hu, %hu, %hu, %hu)", uiRow, uiCol, bColor, bAttr, usChar)); - return hb_gt_PutChar( uiRow, uiCol, bColor, bAttr, usChar ) ? - SUCCESS : FAILURE; + pGT = hb_gt_Base(); + if( pGT ) + { + if( HB_GTSELF_PUTCHAR( pGT, uiRow, uiCol, bColor, bAttr, usChar ) ) + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtBeginWrite( void ) @@ -416,332 +594,516 @@ HB_EXPORT ERRCODE hb_gtBeginWrite( void ) HB_EXPORT ERRCODE hb_gtEndWrite( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtEndWrite()")); - hb_gt_Flush(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtGetBlink( BOOL * bpBlink ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtGetBlink(%p)", bpBlink)); - *bpBlink = hb_gt_GetBlink(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + *bpBlink = HB_GTSELF_GETBLINK( pGT ); + return SUCCESS; + } + return FAILURE; } -HB_EXPORT ERRCODE hb_gtSetBlink( BOOL bBlink ) +HB_EXPORT ERRCODE hb_gtSetBlink( BOOL fBlink ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gtSetBlink(%d)", (int) bBlink)); + PHB_GT pGT; - hb_gt_SetBlink( bBlink ); + HB_TRACE(HB_TR_DEBUG, ("hb_gtSetBlink(%d)", (int) fBlink)); - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_SETBLINK( pGT, fBlink ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtSetMode( USHORT uiRows, USHORT uiCols ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtSetMode(%hu, %hu)", uiRows, uiCols)); - if( !hb_gt_SetMode( uiRows, uiCols ) ) - return FAILURE; - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + if( HB_GTSELF_SETMODE( pGT, uiRows, uiCols ) ) + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtWriteAt( USHORT uiRow, USHORT uiCol, BYTE * pStr, ULONG ulLength ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtWriteAt(%hu, %hu, %p, %lu)", uiRow, uiCol, pStr, ulLength)); - hb_gt_WriteAt( uiRow, uiCol, pStr, ulLength ); - hb_gt_Flush(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_WRITEAT( pGT, uiRow, uiCol, pStr, ulLength ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtWrite( BYTE * pStr, ULONG ulLength ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtWrite(%p, %lu)", pStr, ulLength)); - hb_gt_Write( pStr, ulLength ); - hb_gt_Flush(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_WRITE( pGT, pStr, ulLength ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtWriteCon( BYTE * pStr, ULONG ulLength ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtWriteCon(%p, %lu)", pStr, ulLength)); - hb_gt_WriteCon( pStr, ulLength ); - hb_gt_Flush(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_WRITECON( pGT, pStr, ulLength ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtScroll( USHORT uiTop, USHORT uiLeft, USHORT uiBottom, USHORT uiRight, SHORT iRows, SHORT iCols ) { HB_TRACE(HB_TR_DEBUG, ("hb_gtScroll(%hu, %hu, %hu, %hu, %hd, %hd)", uiTop, uiLeft, uiBottom, uiRight, iRows, iCols)); - if( uiTop > uiBottom || uiLeft > uiRight ) - return FAILURE; - - hb_gt_Scroll( uiTop, uiLeft, uiBottom, uiRight, ( BYTE ) hb_gt_GetColor(), ' ', iRows, iCols ); - hb_gt_Flush(); - - return SUCCESS; + if( uiTop <= uiBottom && uiLeft <= uiRight ) + { + PHB_GT pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_SCROLL( pGT, uiTop, uiLeft, uiBottom, uiRight, + HB_GTSELF_GETCOLOR( pGT ), ' ', iRows, iCols ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtScrollUp( USHORT uiRows ) { HB_TRACE(HB_TR_DEBUG, ("hb_gtScrollUp(%hd)", uiRows)); - if( uiRows == 0 ) - return FAILURE; - - hb_gt_ScrollUp( uiRows, ( BYTE ) hb_gt_GetColor(), ' ' ); - hb_gt_Flush(); - - return SUCCESS; + if( uiRows != 0 ) + { + PHB_GT pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_SCROLLUP( pGT, uiRows, HB_GTSELF_GETCOLOR( pGT ), ' ' ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtDrawShadow( USHORT uiTop, USHORT uiLeft, USHORT uiBottom, USHORT uiRight, BYTE byAttr ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtDrawShadow(%hu, %hu, %hu, %hu, %d)", uiTop, uiLeft, uiBottom, uiRight, (int) byAttr)); - hb_gt_DrawShadow( uiTop, uiLeft, uiBottom, uiRight, byAttr ); - hb_gt_Flush(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_DRAWSHADOW( pGT, uiTop, uiLeft, uiBottom, uiRight, byAttr ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtTone( double dFrequency, double dDuration ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtTone(%lf, %lf)", dFrequency, dDuration)); - hb_gt_Tone( dFrequency, dDuration ); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_TONE( pGT, dFrequency, dDuration ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT char * hb_gtVersion( int iType ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtVersion(%d)",iType)); - return hb_gt_Version( iType ); + pGT = hb_gt_Base(); + return ( char * ) ( pGT ? HB_GTSELF_VERSION( pGT, iType ) : "" ); } HB_EXPORT ERRCODE hb_gtSetAttribute( USHORT uiTop, USHORT uiLeft, USHORT uiBottom, USHORT uiRight, BYTE byAttr ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtSetAttribute(%hu, %hu, %hu, %hu, %d)", uiTop, uiLeft, uiBottom, uiRight, (int) byAttr)); - hb_gt_SetAttribute( uiTop, uiLeft, uiBottom, uiRight, byAttr ); - hb_gt_Flush(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_SETATTRIBUTE( pGT, uiTop, uiLeft, uiBottom, uiRight, byAttr ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + return FAILURE; } /* prepare the terminal for system call */ HB_EXPORT ERRCODE hb_gtSuspend( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtSuspend()")); - if( !hb_gt_Suspend() ) - return FAILURE; - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + if( HB_GTSELF_SUSPEND( pGT ) ) + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtResume( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtResume()")); - if( !hb_gt_Resume() ) - return FAILURE; - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + if( HB_GTSELF_RESUME( pGT ) ) + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtOutStd( BYTE * pbyStr, ULONG ulLen ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtOutStd(%p, %lu)", pbyStr, ulLen)); - hb_gt_OutStd( pbyStr, ulLen ); + pGT = hb_gt_Base(); + if( pGT ) + HB_GTSELF_OUTSTD( pGT, pbyStr, ulLen ); + else + hb_fsWriteLarge( HB_STDOUT_HANDLE, pbyStr, ulLen ); return SUCCESS; } HB_EXPORT ERRCODE hb_gtOutErr( BYTE * pbyStr, ULONG ulLen ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtOutErr(%p, %lu)", pbyStr, ulLen)); - hb_gt_OutErr( pbyStr, ulLen ); + pGT = hb_gt_Base(); + if( pGT ) + HB_GTSELF_OUTERR( pGT, pbyStr, ulLen ); + else + hb_fsWriteLarge( HB_STDERR_HANDLE, pbyStr, ulLen ); return SUCCESS; } ERRCODE hb_gtSetDispCP( char * pszTermCDP, char * pszHostCDP, BOOL fBox ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtSetDispCP(%s, %s, %d)", pszTermCDP, pszHostCDP, fBox)); - if( hb_gt_SetDispCP( pszTermCDP, pszHostCDP, fBox ) ) - return SUCCESS; - else - return FAILURE; + pGT = hb_gt_Base(); + if( pGT ) + { + if( HB_GTSELF_SETDISPCP( pGT, pszTermCDP, pszHostCDP, fBox ) ) + return SUCCESS; + } + return FAILURE; } ERRCODE hb_gtSetKeyCP( char * pszTermCDP, char * pszHostCDP ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtSetKeyCP(%s, %s)", pszTermCDP, pszHostCDP)); - if( hb_gt_SetKeyCP( pszTermCDP, pszHostCDP ) ) - return SUCCESS; - else - return FAILURE; + pGT = hb_gt_Base(); + if( pGT ) + { + if( HB_GTSELF_SETKEYCP( pGT, pszTermCDP, pszHostCDP ) ) + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtInfo( int iType, PHB_GT_INFO pInfo ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtInfo(%d, %p)", iType, pInfo)); - if( hb_gt_Info( iType, pInfo ) ) - return SUCCESS; - else - return FAILURE; + pGT = hb_gt_Base(); + if( pGT ) + { + if( HB_GTSELF_INFO( pGT, iType, pInfo ) ) + return SUCCESS; + } + return FAILURE; } HB_EXPORT int hb_gtAlert( PHB_ITEM pMessage, PHB_ITEM pOptions, int iClrNorm, int iClrHigh, double dDelay ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtAlert(%p, %p, %d, %d, %f)", pMessage, pOptions, iClrNorm, iClrHigh, dDelay)); - return hb_gt_Alert( pMessage, pOptions, iClrNorm, iClrHigh, dDelay ); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_ALERT( pGT, pMessage, pOptions, iClrNorm, + iClrHigh, dDelay ) : 0; } HB_EXPORT int hb_gtSetFlag( int iType, int iNewValue ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtSetFlag(%d, %d)", iType, iNewValue)); - return hb_gt_SetFlag( iType, iNewValue ); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_SETFLAG( pGT, iType, iNewValue ) : 0; } HB_EXPORT int hb_gtGetCurrColor( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtGetCurrColor()")); - return hb_gt_GetColor(); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_GETCOLOR( pGT ) : 0x07; } HB_EXPORT int hb_gtGetClearColor( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtGetClearColor()")); - return hb_gt_GetClearColor(); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_GETCLEARCOLOR( pGT ) : 0x07; } HB_EXPORT ERRCODE hb_gtSetClearColor( int iColor ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtSetClearColor(%d)", iColor)); - hb_gt_SetClearColor( iColor ); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_SETCLEARCOLOR( pGT, iColor ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT int hb_gtGetClearChar( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtGetClearChar()")); - return hb_gt_GetClearChar(); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_GETCLEARCHAR( pGT ) : ' '; } HB_EXPORT ERRCODE hb_gtSetClearChar( int iChar ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtSetClearChar(%d)", iChar)); - hb_gt_SetClearChar( iChar ); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_SETCLEARCHAR( pGT, iChar ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtGetScrChar( int iRow, int iCol, BYTE * pbColor, BYTE * pbAttr, USHORT * pusChar ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtScrGetChar(%d, %d, %p, %p, %p)", iRow, iCol, pbColor, pbAttr, pusChar)); - return hb_gt_GetScrChar( iRow, iCol, pbColor, pbAttr, pusChar ) ? - SUCCESS : FAILURE; + pGT = hb_gt_Base(); + if( pGT ) + { + if( HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol, pbColor, pbAttr, pusChar ) ) + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtPutScrChar( int iRow, int iCol, BYTE bColor, BYTE bAttr, USHORT usChar ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtPutScrChar(%d, %d, %d, %d, %hu)", iRow, iCol, bColor, bAttr, usChar)); - return hb_gt_PutScrChar( iRow, iCol, bColor, bAttr, usChar ) ? - SUCCESS : FAILURE; + pGT = hb_gt_Base(); + if( pGT ) + { + if( HB_GTSELF_PUTSCRCHAR( pGT, iRow, iCol, bColor, bAttr, usChar ) ) + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtFlush( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtFlush()")); - hb_gt_Flush(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtGetPosEx( int * piRow, int * piCol ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtGetPosEx(%p, %p)", piRow, piCol)); - hb_gt_GetPos( piRow, piCol ); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_GETPOS( pGT, piRow, piCol ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtScrollEx( int iTop, int iLeft, int iBottom, int iRight, BYTE bColor, BYTE bChar, int iRows, int iCols ) { HB_TRACE(HB_TR_DEBUG, ("hb_gtScrollEx(%d, %d, %d, %d, %d, %hd, %d, %d)", iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols)); - if( iTop > iBottom || iLeft > iRight ) - return FAILURE; - - hb_gt_Scroll( iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols ); - hb_gt_Flush(); - - return SUCCESS; + if( iTop <= iBottom && iLeft <= iRight ) + { + PHB_GT pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_SCROLL( pGT, iTop, iLeft, iBottom, iRight, + bColor, bChar, iRows, iCols ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + } + return FAILURE; } HB_EXPORT ERRCODE hb_gtBoxEx( int iTop, int iLeft, int iBottom, int iRight, BYTE * pbyFrame, BYTE bColor ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtBoxEx(%d, %d, %d, %d, %p, %d)", iTop, iLeft, iBottom, iRight, pbyFrame, bColor)); - hb_gt_Box( iTop, iLeft, iBottom, iRight, pbyFrame, bColor ); - hb_gt_SetPos( iTop + 1, iLeft + 1 ); - hb_gt_Flush(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_BOX( pGT, iTop, iLeft, iBottom, iRight, pbyFrame, bColor ); + HB_GTSELF_SETPOS( pGT, iTop + 1, iLeft + 1 ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + return FAILURE; } HB_EXPORT int hb_gtGfxPrimitive( int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor ) { - int iResult; + PHB_GT pGT; + int iResult = 0; HB_TRACE(HB_TR_DEBUG, ("hb_gtGfxText(%d, %d, %d, %d, %d, %d)", iType, iTop, iLeft, iBottom, iRight, iColor)); - iResult = hb_gt_GfxPrimitive( iType, iTop, iLeft, iBottom, iRight, iColor ); - hb_gt_Flush(); + pGT = hb_gt_Base(); + if( pGT ) + { + iResult = HB_GTSELF_GFXPRIMITIVE( pGT, iType, iTop, iLeft, iBottom, iRight, iColor ); + HB_GTSELF_FLUSH( pGT ); + } return iResult; } HB_EXPORT ERRCODE hb_gtGfxText( int iTop, int iLeft, char * cBuf, int iColor, int iSize, int iWidth ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_gtGfxText(%d, %d, %s, %d, %d, %d)", iTop, iLeft, cBuf, iColor, iSize, iWidth)); - hb_gt_GfxText( iTop, iLeft, cBuf, iColor, iSize, iWidth ); - hb_gt_Flush(); - - return SUCCESS; + pGT = hb_gt_Base(); + if( pGT ) + { + HB_GTSELF_GFXTEXT( pGT, iTop, iLeft, cBuf, iColor, iSize, iWidth ); + HB_GTSELF_FLUSH( pGT ); + return SUCCESS; + } + return FAILURE; } diff --git a/harbour/source/rtl/gtcgi/gtcgi.c b/harbour/source/rtl/gtcgi/gtcgi.c index 747c523790..212f9fe2ea 100644 --- a/harbour/source/rtl/gtcgi/gtcgi.c +++ b/harbour/source/rtl/gtcgi/gtcgi.c @@ -106,9 +106,9 @@ static void hb_gt_cgi_newLine( void ) hb_gt_cgi_termOut( s_szCrLf, s_ulCrLf ); } -static void hb_gt_cgi_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) +static void hb_gt_cgi_Init( PHB_GT pGT, FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Init(%p,%p,%p)", hFilenoStdin, hFilenoStdout, hFilenoStderr ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Init(%p,%p,%p,%p)", pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr ) ); s_hFilenoStdin = hFilenoStdin; s_hFilenoStdout = hFilenoStdout; @@ -123,21 +123,21 @@ static void hb_gt_cgi_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hb_fsSetDevMode( s_hFilenoStdout, FD_BINARY ); - HB_GTSUPER_INIT( hFilenoStdin, hFilenoStdout, hFilenoStderr ); - hb_gt_SetFlag( GTI_STDOUTCON, TRUE ); + HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr ); + HB_GTSELF_SETFLAG( pGT, GTI_STDOUTCON, TRUE ); } -static void hb_gt_cgi_Exit( void ) +static void hb_gt_cgi_Exit( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_cgi_Exit()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_cgi_Exit(%p)", pGT)); - hb_gt_Refresh(); + HB_GTSELF_REFRESH( pGT ); /* update cursor position on exit */ if( s_iLastCol > 0 ) hb_gt_cgi_newLine(); - HB_GTSUPER_EXIT(); + HB_GTSUPER_EXIT( pGT ); if( s_iLineBufSize > 0 ) { @@ -146,32 +146,39 @@ static void hb_gt_cgi_Exit( void ) } } -static int hb_gt_cgi_ReadKey( int iEventMask ) +static int hb_gt_cgi_ReadKey( PHB_GT pGT, int iEventMask ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_cgi_ReadKey(%d)", iEventMask)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_cgi_ReadKey(%p,%d)", pGT, iEventMask)); + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( iEventMask ); return 13; } -static BOOL hb_gt_cgi_IsColor( void ) +static BOOL hb_gt_cgi_IsColor( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_cgi_IsColor()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_cgi_IsColor(%p)", pGT)); + + HB_SYMBOL_UNUSED( pGT ); return FALSE; } -static void hb_gt_cgi_Bell( void ) +static void hb_gt_cgi_Bell( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_gt_cgi_Bell()" ) ); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_cgi_Bell(%p)", pGT)); + + HB_SYMBOL_UNUSED( pGT ); hb_gt_cgi_termOut( s_szBell, 1 ); } -static char * hb_gt_cgi_Version( int iType ) +static char * hb_gt_cgi_Version( PHB_GT pGT, int iType ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Version(%d)", iType ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Version(%p,%d)", pGT, iType ) ); + + HB_SYMBOL_UNUSED( pGT ); if( iType == 0 ) return HB_GT_DRVNAME( HB_GT_NAME ); @@ -179,21 +186,21 @@ static char * hb_gt_cgi_Version( int iType ) return "Harbour Terminal: Raw stream console"; } -static void hb_gt_cgi_Scroll( int iTop, int iLeft, int iBottom, int iRight, +static void hb_gt_cgi_Scroll( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE bColor, BYTE bChar, int iRows, int iCols ) { int iHeight, iWidth; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Scroll(%d,%d,%d,%d,%d,%d,%d,%d)", iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Scroll(%p,%d,%d,%d,%d,%d,%d,%d,%d)", pGT, iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols ) ); /* Provide some basic scroll support for full screen */ - hb_gt_GetSize( &iHeight, &iWidth ); + HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth ); if( iCols == 0 && iRows > 0 && iTop == 0 && iLeft == 0 && iBottom >= iHeight - 1 && iRight >= iWidth - 1 ) { /* scroll up the internal screen buffer */ - HB_GTSUPER_SCROLLUP( iRows, bColor, bChar ); + HB_GTSUPER_SCROLLUP( pGT, iRows, bColor, bChar ); /* update our internal row position */ s_iRow -= iRows; if( s_iRow < 0 ) @@ -201,14 +208,14 @@ static void hb_gt_cgi_Scroll( int iTop, int iLeft, int iBottom, int iRight, s_iLastCol = s_iCol = 0; } else - HB_GTSUPER_SCROLL( iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols ); + HB_GTSUPER_SCROLL( pGT, iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols ); } -static BOOL hb_gt_cgi_SetDispCP( char *pszTermCDP, char *pszHostCDP, BOOL fBox ) +static BOOL hb_gt_cgi_SetDispCP( PHB_GT pGT, char *pszTermCDP, char *pszHostCDP, BOOL fBox ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_SetDispCP(%s,%s,%d)", pszTermCDP, pszHostCDP, (int) fBox ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_SetDispCP(%p,%s,%s,%d)", pGT, pszTermCDP, pszHostCDP, (int) fBox ) ); - HB_GTSUPER_SETDISPCP( pszTermCDP, pszHostCDP, fBox ); + HB_GTSUPER_SETDISPCP( pGT, pszTermCDP, pszHostCDP, fBox ); #ifndef HB_CDP_SUPPORT_OFF if( !pszHostCDP ) @@ -230,7 +237,7 @@ static BOOL hb_gt_cgi_SetDispCP( char *pszTermCDP, char *pszHostCDP, BOOL fBox ) #ifdef HB_GT_CGI_RAWOUTPUT -static void hb_gt_cgi_WriteCon( BYTE * pText, ULONG ulLength ) +static void hb_gt_cgi_WriteCon( PHB_GT pGT, BYTE * pText, ULONG ulLength ) { BYTE * buffer = NULL; @@ -269,13 +276,13 @@ static void hb_gt_cgi_WriteCon( BYTE * pText, ULONG ulLength ) ++s_iCol; } } - HB_GTSUPER_SETPOS( s_iRow, s_iCol ); + HB_GTSUPER_SETPOS( pGT, s_iRow, s_iCol ); if( buffer ) hb_xfree( buffer ); } -static void hb_gt_cgi_WriteAt( int iRow, int iCol, 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; @@ -305,20 +312,20 @@ static void hb_gt_cgi_WriteAt( int iRow, int iCol, BYTE * pText, ULONG ulLength s_iRow = iRow; s_iCol = iCol; - hb_gt_cgi_WriteCon( pText, ulLength ); + hb_gt_cgi_WriteCon( pGT, pText, ulLength ); } #else /* HB_GT_CGI_RAWOUTPUT */ -static void hb_gt_cgi_Redraw( int iRow, int iCol, int iSize ) +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; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Redraw(%d, %d, %d)", iRow, iCol, iSize ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Redraw(%p,%d,%d,%d)", pGT, iRow, iCol, iSize ) ); - hb_gt_GetSize( &iHeight, &iWidth ); + HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth ); iLineFeed = iLen = 0; if( s_iRow != iRow ) @@ -340,7 +347,7 @@ static void hb_gt_cgi_Redraw( int iRow, int iCol, int iSize ) } while( iSize > 0 && iCol + iSize > s_iLastCol && - hb_gt_GetScrChar( iRow, iCol + iSize - 1, &bColor, &bAttr, &usChar ) ) + HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol + iSize - 1, &bColor, &bAttr, &usChar ) ) { if( usChar != ' ' ) break; @@ -355,7 +362,7 @@ static void hb_gt_cgi_Redraw( int iRow, int iCol, int iSize ) while( iLen < iSize ) { - if( !hb_gt_GetScrChar( iRow, iCol, &bColor, &bAttr, &usChar ) ) + if( !HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol, &bColor, &bAttr, &usChar ) ) break; s_sLineBuf[ iLen++ ] = ( BYTE ) usChar; ++iCol; @@ -374,13 +381,13 @@ static void hb_gt_cgi_Redraw( int iRow, int iCol, int iSize ) } } -static void hb_gt_cgi_Refresh( void ) +static void hb_gt_cgi_Refresh( PHB_GT pGT ) { int iHeight, iWidth; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Refresh()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_cgi_Refresh(%p)", pGT ) ); - hb_gt_GetSize( &iHeight, &iWidth ); + HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth ); if( s_iLineBufSize == 0 ) { s_sLineBuf = ( BYTE * ) hb_xgrab( iWidth ); @@ -391,7 +398,7 @@ static void hb_gt_cgi_Refresh( void ) s_sLineBuf = ( BYTE * ) hb_xrealloc( s_sLineBuf, iWidth ); s_iLineBufSize = iWidth; } - HB_GTSUPER_REFRESH(); + HB_GTSUPER_REFRESH( pGT ); } #endif /* HB_GT_CGI_RAWOUTPUT */ diff --git a/harbour/source/rtl/gtcrs/gtcrs.c b/harbour/source/rtl/gtcrs/gtcrs.c index 2a8d7c4039..6192b6a715 100644 --- a/harbour/source/rtl/gtcrs/gtcrs.c +++ b/harbour/source/rtl/gtcrs/gtcrs.c @@ -2446,11 +2446,11 @@ void HB_GT_FUNC( gt_CatchSignal( int iSig ) ) /* *********************************************************************** */ -static void hb_gt_crs_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) +static void hb_gt_crs_Init( PHB_GT pGT, FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) { InOutBase *ioBase; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Init(%p,%p,%p)", hFilenoStdin, hFilenoStdout, hFilenoStderr ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Init(%p,%p,%p,%p)", pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr ) ); if( !s_ioBase ) { @@ -2470,10 +2470,10 @@ static void hb_gt_crs_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE if( ioBase ) { add_new_ioBase( ioBase ); - HB_GTSUPER_INIT( hFilenoStdin, hFilenoStdout, hFilenoStderr ); - HB_GTSUPER_RESIZE( s_ioBase->maxrow, s_ioBase->maxcol ); - hb_gt_SetFlag( GTI_COMPATBUFFER, FALSE ); - hb_gt_SetBlink( TRUE ); + HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr ); + HB_GTSUPER_RESIZE( pGT, s_ioBase->maxrow, s_ioBase->maxcol ); + HB_GTSELF_SETFLAG( pGT, GTI_COMPATBUFFER, FALSE ); + HB_GTSELF_SETBLINK( pGT, TRUE ); } } @@ -2483,33 +2483,35 @@ static void hb_gt_crs_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE /* *********************************************************************** */ -static void hb_gt_crs_Exit( void ) +static void hb_gt_crs_Exit( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Exit()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Exit(%p)", pGT ) ); - HB_GTSUPER_EXIT(); + HB_GTSUPER_EXIT( pGT ); del_all_ioBase(); } /* *********************************************************************** */ -static BOOL hb_gt_crs_IsColor( void ) +static BOOL hb_gt_crs_IsColor( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_IsColor()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_IsColor(%p)", pGT ) ); + + HB_SYMBOL_UNUSED( pGT ); return s_ioBase->is_color; } /* *********************************************************************** */ -static BOOL hb_gt_crs_SetMode( int iRows, int iCols ) +static BOOL hb_gt_crs_SetMode( PHB_GT pGT, int iRows, int iCols ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_SetMode(%d, %d)", iRows, iCols ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_SetMode(%p,%d,%d)", pGT, iRows, iCols ) ); if( gt_setsize( s_ioBase, iRows, iCols ) == 0 ) { - HB_GTSUPER_RESIZE( iRows, iCols ); + HB_GTSUPER_RESIZE( pGT, iRows, iCols ); return TRUE; } return FALSE; @@ -2517,23 +2519,25 @@ static BOOL hb_gt_crs_SetMode( int iRows, int iCols ) /* *********************************************************************** */ -static void hb_gt_crs_SetBlink( BOOL fBlink ) +static void hb_gt_crs_SetBlink( PHB_GT pGT, BOOL fBlink ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_SetBlink(%d)", ( int ) fBlink ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_SetBlink(%p, %d)", pGT, ( int ) fBlink ) ); if( fBlink ) s_ioBase->attr_mask |= A_BLINK; else s_ioBase->attr_mask &= ~A_BLINK; - HB_GTSUPER_SETBLINK( fBlink ); + HB_GTSUPER_SETBLINK( pGT, fBlink ); } /* *********************************************************************** */ -static void hb_gt_crs_Tone( double dFrequency, double dDuration ) +static void hb_gt_crs_Tone( PHB_GT pGT, double dFrequency, double dDuration ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Tone(%lf, %lf)", dFrequency, dDuration ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Tone(%p,%lf,%lf)", pGT, dFrequency, dDuration ) ); + + HB_SYMBOL_UNUSED( pGT ); gt_tone( s_ioBase, dFrequency, dDuration ); @@ -2546,9 +2550,11 @@ static void hb_gt_crs_Tone( double dFrequency, double dDuration ) /* *********************************************************************** */ -static char * hb_gt_crs_Version( int iType ) +static char * hb_gt_crs_Version( PHB_GT pGT, int iType ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Version(%d)", iType ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Version(%p,%d)", pGT, iType ) ); + + HB_SYMBOL_UNUSED( pGT ); if( iType == 0 ) return HB_GT_DRVNAME( HB_GT_NAME ); @@ -2558,42 +2564,44 @@ static char * hb_gt_crs_Version( int iType ) /* *********************************************************************** */ -static void hb_gt_crs_OutStd( BYTE * pbyStr, ULONG ulLen ) +static void hb_gt_crs_OutStd( PHB_GT pGT, BYTE * pbyStr, ULONG ulLen ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_OutStd(%s, %hu)", pbyStr, ulLen ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_OutStd(%p,%s,%lu)", pGT, pbyStr, ulLen ) ); if( s_ioBase ) { if( s_ioBase->stdoutfd == -1 ) - hb_gt_WriteCon( pbyStr, ulLen ); + HB_GTSELF_WRITECON( pGT, pbyStr, ulLen ); else gt_outstd( s_ioBase, pbyStr, ulLen ); } else - HB_GTSUPER_OUTSTD( pbyStr, ulLen ); + HB_GTSUPER_OUTSTD( pGT, pbyStr, ulLen ); } /* *********************************************************************** */ -static void hb_gt_crs_OutErr( BYTE * pbyStr, ULONG ulLen ) +static void hb_gt_crs_OutErr( PHB_GT pGT, BYTE * pbyStr, ULONG ulLen ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_OutErr(%s, %hu)", pbyStr, ulLen ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_OutErr(%p,%s,%lu)", pGT, pbyStr, ulLen ) ); if( s_ioBase ) { if( s_ioBase->stderrfd == -1 ) - hb_gt_WriteCon( pbyStr, ulLen ); + HB_GTSELF_WRITECON( pGT, pbyStr, ulLen ); else gt_outerr( s_ioBase, ( char * ) pbyStr, ulLen ); } else - HB_GTSUPER_OUTERR( pbyStr, ulLen ); + HB_GTSUPER_OUTERR( pGT, pbyStr, ulLen ); } /* *********************************************************************** */ -static BOOL hb_gt_crs_Suspend( void ) +static BOOL hb_gt_crs_Suspend( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Suspend()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Suspend(%p)", pGT ) ); + + HB_SYMBOL_UNUSED( pGT ); if( s_ioBase ) { @@ -2606,9 +2614,11 @@ static BOOL hb_gt_crs_Suspend( void ) /* *********************************************************************** */ -static BOOL hb_gt_crs_Resume( void ) +static BOOL hb_gt_crs_Resume( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Resume()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Resume(%p)", pGT ) ); + + HB_SYMBOL_UNUSED( pGT ); if( s_ioBase ) { @@ -2623,9 +2633,11 @@ static BOOL hb_gt_crs_Resume( void ) /* *********************************************************************** */ -static BOOL hb_gt_crs_PreExt( void ) +static BOOL hb_gt_crs_PreExt( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_PreExt()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_PreExt(%p)", pGT ) ); + + HB_SYMBOL_UNUSED( pGT ); if( s_ioBase ) { @@ -2636,27 +2648,33 @@ static BOOL hb_gt_crs_PreExt( void ) /* *********************************************************************** */ -static BOOL hb_gt_crs_PostExt( void ) +static BOOL hb_gt_crs_PostExt( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_PostExt()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_PostExt(%p)", pGT ) ); + + HB_SYMBOL_UNUSED( pGT ); return TRUE; } /* *********************************************************************** */ -static BOOL hb_gt_crs_mouse_IsPresent( void ) +static BOOL hb_gt_crs_mouse_IsPresent( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_mouse_IsPresent()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_mouse_IsPresent(%p)", pGT ) ); + + HB_SYMBOL_UNUSED( pGT ); return s_ioBase->mouse_type != MOUSE_NONE; } /* *********************************************************************** */ -static void hb_gt_crs_mouse_Show( void ) +static void hb_gt_crs_mouse_Show( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_mouse_Show()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_mouse_Show(%p)", pGT ) ); + + HB_SYMBOL_UNUSED( pGT ); #ifdef HAVE_GPM_H if( s_ioBase->mouse_type == MOUSE_GPM ) @@ -2667,9 +2685,11 @@ static void hb_gt_crs_mouse_Show( void ) /* *********************************************************************** */ -static void hb_gt_crs_mouse_Hide( void ) +static void hb_gt_crs_mouse_Hide( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_mouse_Hide()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_mouse_Hide(%p)", pGT ) ); + + HB_SYMBOL_UNUSED( pGT ); #ifdef HAVE_GPM_H if( s_ioBase->mouse_type == MOUSE_GPM ) @@ -2681,9 +2701,11 @@ static void hb_gt_crs_mouse_Hide( void ) /* *********************************************************************** */ -static void hb_gt_crs_mouse_GetPos( int * piRow, int * piCol ) +static void hb_gt_crs_mouse_GetPos( PHB_GT pGT, int * piRow, int * piCol ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_mouse_Col(%p,%p)", piRow, piCol ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_mouse_Col(%p,%p,%p)", pGT, piRow, piCol ) ); + + HB_SYMBOL_UNUSED( pGT ); *piRow = s_ioBase->mLastEvt.row; *piCol = s_ioBase->mLastEvt.col; @@ -2691,9 +2713,11 @@ static void hb_gt_crs_mouse_GetPos( int * piRow, int * piCol ) /* *********************************************************************** */ -static void hb_gt_crs_mouse_SetPos( int iRow, int iCol ) +static void hb_gt_crs_mouse_SetPos( PHB_GT pGT, int iRow, int iCol ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_mouse_SetPos(%i, %i)", iRow, iCol ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_mouse_SetPos(%p,%i,%i)", pGT, iRow, iCol ) ); + + HB_SYMBOL_UNUSED( pGT ); /* it does really nothing */ s_ioBase->mLastEvt.col = iCol; @@ -2703,11 +2727,13 @@ static void hb_gt_crs_mouse_SetPos( int iRow, int iCol ) /* *********************************************************************** */ -static BOOL hb_gt_crs_mouse_ButtonState( int iButton ) +static BOOL hb_gt_crs_mouse_ButtonState( PHB_GT pGT, int iButton ) { BOOL ret = FALSE; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_mouse_ButtonState(%i)", iButton ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_mouse_ButtonState(%p,%i)", pGT, iButton ) ); + + HB_SYMBOL_UNUSED( pGT ); if( s_ioBase->mouse_type != 0 ) { @@ -2730,26 +2756,30 @@ static BOOL hb_gt_crs_mouse_ButtonState( int iButton ) /* *********************************************************************** */ -static int hb_gt_crs_mouse_CountButton( void ) +static int hb_gt_crs_mouse_CountButton( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_mouse_CountButton()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_mouse_CountButton(%p)", pGT ) ); + + HB_SYMBOL_UNUSED( pGT ); return ( s_ioBase->mButtons ); } -static void hb_gt_crs_mouse_SetDoubleClickSpeed( int iSpeed ) +static void hb_gt_crs_mouse_SetDoubleClickSpeed( PHB_GT pGT, int iSpeed ) { - HB_GTSUPER_MOUSESETDOUBLECLICKSPEED( iSpeed ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_mouse_SetDoubleClickSpeed(%p,%d)", pGT, iSpeed ) ); + + HB_GTSUPER_MOUSESETDOUBLECLICKSPEED( pGT, iSpeed ); s_ioBase->mLastEvt.click_delay = iSpeed; } /* *********************************************************************** */ -static int hb_gt_crs_ReadKey( int iEventMask ) +static int hb_gt_crs_ReadKey( PHB_GT pGT, int iEventMask ) { int iKey; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_ReadKey(%d)", iEventMask ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_ReadKey(%p,%d)", pGT, iEventMask ) ); HB_SYMBOL_UNUSED( iEventMask ); @@ -2758,7 +2788,7 @@ static int hb_gt_crs_ReadKey( int iEventMask ) if( iKey == K_RESIZE ) { gt_resize( s_ioBase ); - HB_GTSUPER_RESIZE( s_ioBase->maxrow, s_ioBase->maxcol ); + HB_GTSUPER_RESIZE( pGT, s_ioBase->maxrow, s_ioBase->maxcol ); iKey = 0; } @@ -2767,11 +2797,11 @@ static int hb_gt_crs_ReadKey( int iEventMask ) /* *********************************************************************** */ -static BOOL hb_gt_crs_SetDispCP( char *pszTermCDP, char *pszHostCDP, BOOL fBox ) +static BOOL hb_gt_crs_SetDispCP( PHB_GT pGT, char *pszTermCDP, char *pszHostCDP, BOOL fBox ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_SetDispCP(%s,%s,%d)", pszTermCDP, pszHostCDP, (int) fBox ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_SetDispCP(%p,%s,%s,%d)", pGT, pszTermCDP, pszHostCDP, (int) fBox ) ); - HB_GTSUPER_SETDISPCP( pszTermCDP, pszHostCDP, fBox ); + HB_GTSUPER_SETDISPCP( pGT, pszTermCDP, pszHostCDP, fBox ); #ifndef HB_CDP_SUPPORT_OFF if( !pszHostCDP || !*pszHostCDP ) @@ -2816,9 +2846,11 @@ static BOOL hb_gt_crs_SetDispCP( char *pszTermCDP, char *pszHostCDP, BOOL fBox ) /* *********************************************************************** */ -static BOOL hb_gt_crs_SetKeyCP( char *pszTermCDP, char *pszHostCDP ) +static BOOL hb_gt_crs_SetKeyCP( PHB_GT pGT, char *pszTermCDP, char *pszHostCDP ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_SetKeyCP(%s,%s)", pszTermCDP, pszHostCDP ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_SetKeyCP(%p,%s,%s)", pGT, pszTermCDP, pszHostCDP ) ); + + HB_SYMBOL_UNUSED( pGT ); #ifndef HB_CDP_SUPPORT_OFF if( !pszHostCDP || !*pszHostCDP ) @@ -2859,9 +2891,9 @@ static BOOL hb_gt_crs_SetKeyCP( char *pszTermCDP, char *pszHostCDP ) /* *********************************************************************** */ -static BOOL hb_gt_crs_Info( int iType, PHB_GT_INFO pInfo ) +static BOOL hb_gt_crs_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Info(%d,%p)", iType, pInfo ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Info(%p,%d,%p)", pGT, iType, pInfo ) ); if( s_ioBase ) { @@ -2879,7 +2911,7 @@ static BOOL hb_gt_crs_Info( int iType, PHB_GT_INFO pInfo ) break; default: - return HB_GTSUPER_INFO( iType, pInfo ); + return HB_GTSUPER_INFO( pGT, iType, pInfo ); } } @@ -2889,9 +2921,9 @@ static BOOL hb_gt_crs_Info( int iType, PHB_GT_INFO pInfo ) /* *********************************************************************** */ -static void hb_gt_crs_Redraw( int iRow, int iCol, int iSize ) +static void hb_gt_crs_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Redraw(%d, %d, %d)", iRow, iCol, iSize ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Redraw(%p,%d,%d,%d)", pGT, iRow, iCol, iSize ) ); if( s_ioBase ) { @@ -2902,7 +2934,7 @@ static void hb_gt_crs_Redraw( int iRow, int iCol, int iSize ) wmove( s_ioBase->stdscr, iRow, iCol ); while( iSize-- > 0 ) { - if( !hb_gt_GetScrChar( iRow, iCol++, &bColor, &bAttr, &usChar ) ) + if( !HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol++, &bColor, &bAttr, &usChar ) ) break; ch = ( s_ioBase->attr_map[ bColor ] & s_ioBase->attr_mask ) | ( bAttr & HB_GT_ATTR_BOX ? s_ioBase->box_chmap[ usChar & 0xff ] : @@ -2914,16 +2946,16 @@ static void hb_gt_crs_Redraw( int iRow, int iCol, int iSize ) /* *********************************************************************** */ -static void hb_gt_crs_Refresh( void ) +static void hb_gt_crs_Refresh( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Refresh()") ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_crs_Refresh(%p)", pGT ) ); - HB_GTSUPER_REFRESH(); + HB_GTSUPER_REFRESH( pGT ); if( s_ioBase ) { int iRow, iCol, iShape; - hb_gt_GetScrCursor( &iRow, &iCol, &iShape ); + HB_GTSELF_GETSCRCURSOR( pGT, &iRow, &iCol, &iShape ); s_ioBase->row = iRow; s_ioBase->col = iCol; set_cursor( s_ioBase, iShape ); diff --git a/harbour/source/rtl/gtcrs/gtcrs.h b/harbour/source/rtl/gtcrs/gtcrs.h index 43266ea52a..5a91582474 100644 --- a/harbour/source/rtl/gtcrs/gtcrs.h +++ b/harbour/source/rtl/gtcrs/gtcrs.h @@ -133,8 +133,8 @@ #define ESC_DELAY 25 -/* #define DBLCLK_DELAY 250 */ -#define DBLCLK_DELAY hb_mouse_GetDoubleClickSpeed(); +/* #define DBLCLK_DELAY 168 */ +#define DBLCLK_DELAY hb_mouseGetDoubleClickSpeed() #define MAX_IOBASE 32 #define STDIN_BUFLEN 128 diff --git a/harbour/source/rtl/gtgui/gtgui.c b/harbour/source/rtl/gtgui/gtgui.c index adba000d09..ff049f6829 100644 --- a/harbour/source/rtl/gtgui/gtgui.c +++ b/harbour/source/rtl/gtgui/gtgui.c @@ -70,9 +70,11 @@ static HB_GT_FUNCS SuperTable; /* *********************************************************************** */ -static char * hb_gt_gui_Version( int iType ) +static char * hb_gt_gui_Version( PHB_GT pGT, int iType ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_gui_Version(%d)", iType ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_gui_Version(%p,%d)", pGT, iType ) ); + + HB_SYMBOL_UNUSED( pGT ); if ( iType == 0 ) return HB_GT_DRVNAME( HB_GT_NAME ); @@ -82,22 +84,23 @@ static char * hb_gt_gui_Version( int iType ) /* *********************************************************************** */ /* dDuration is in 'Ticks' (18.2 per second) */ -static void hb_gt_gui_Tone( double dFrequency, double dDuration ) +static void hb_gt_gui_Tone( PHB_GT pGT, double dFrequency, double dDuration ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_gui_Tone(%lf, %lf)", dFrequency, dDuration)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_gui_Tone(%p,%lf,%lf)", pGT, dFrequency, dDuration)); #if defined( HB_OS_WIN_32 ) + HB_SYMBOL_UNUSED( pGT ); hb_gt_w32_tone( dFrequency, dDuration ); #else - HB_GTSUPER_TONE( dFrequency, dDuration ); + HB_GTSUPER_TONE( pGT, dFrequency, dDuration ); #endif } /* *********************************************************************** */ -static BOOL hb_gt_gui_Info( int iType, PHB_GT_INFO pInfo ) +static BOOL hb_gt_gui_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_gui_Info(%d,%p)", iType, pInfo ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_gui_Info(%p,%d,%p)", pGT, iType, pInfo ) ); switch( iType ) { @@ -132,7 +135,7 @@ static BOOL hb_gt_gui_Info( int iType, PHB_GT_INFO pInfo ) break; #endif default: - return HB_GTSUPER_INFO( iType, pInfo ); + return HB_GTSUPER_INFO( pGT, iType, pInfo ); } return TRUE; diff --git a/harbour/source/rtl/gtpca/gtpca.c b/harbour/source/rtl/gtpca/gtpca.c index 2e0c3b621e..077e0430b0 100644 --- a/harbour/source/rtl/gtpca/gtpca.c +++ b/harbour/source/rtl/gtpca/gtpca.c @@ -419,11 +419,11 @@ static void hb_gt_pca_setKeyTrans( char * pSrcChars, char * pDstChars ) } } -static void hb_gt_pca_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) +static void hb_gt_pca_Init( PHB_GT pGT, FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) { int iRows = 25, iCols = 80; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_pca_Init(%p,%p,%p)", hFilenoStdin, hFilenoStdout, hFilenoStderr)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_pca_Init(%p,%p,%p,%p)", pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr)); s_hFilenoStdin = hFilenoStdin; s_hFilenoStdout = hFilenoStdout; @@ -442,7 +442,7 @@ static void hb_gt_pca_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hb_fsSetDevMode( s_hFilenoStdout, FD_BINARY ); - HB_GTSUPER_INIT( hFilenoStdin, hFilenoStdout, hFilenoStderr ); + 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( __DJGPP__ ) ) && \ @@ -501,26 +501,26 @@ static void hb_gt_pca_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE s_sOutBuf = ( BYTE * ) hb_xgrab( s_iOutBufSize ); } - HB_GTSUPER_RESIZE( iRows, iCols ); - hb_gt_SetFlag( GTI_STDOUTCON, s_bStdoutConsole ); - hb_gt_SetFlag( GTI_STDERRCON, s_bStderrConsole ); + HB_GTSUPER_RESIZE( pGT, iRows, iCols ); + HB_GTSELF_SETFLAG( pGT, GTI_STDOUTCON, s_bStdoutConsole ); + HB_GTSELF_SETFLAG( pGT, GTI_STDERRCON, s_bStderrConsole ); hb_gt_pca_AnsiInit(); hb_gt_pca_AnsiGetCurPos( &s_iRow, &s_iCol ); } -static void hb_gt_pca_Exit( void ) +static void hb_gt_pca_Exit( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_pca_Exit()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_pca_Exit(%p)", pGT)); - hb_gt_Refresh(); + HB_GTSELF_REFRESH( pGT ); /* set default color */ hb_gt_pca_AnsiSetAttributes( 0x07 ); hb_gt_pca_AnsiSetCursorStyle( SC_NORMAL ); hb_gt_pca_AnsiSetAutoMargin( 1 ); hb_gt_pca_termFlush(); - HB_GTSUPER_EXIT(); + HB_GTSUPER_EXIT( pGT ); #if defined( OS_UNIX_COMPATIBLE ) || defined( __DJGPP__ ) if( s_fRestTTY ) @@ -539,12 +539,13 @@ static void hb_gt_pca_Exit( void ) s_bStdinConsole = s_bStdoutConsole = s_bStderrConsole = FALSE; } -static int hb_gt_pca_ReadKey( int iEventMask ) +static int hb_gt_pca_ReadKey( PHB_GT pGT, int iEventMask ) { int ch = 0; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_pca_ReadKey(%d)", iEventMask)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_pca_ReadKey(%p,%d)", pGT, iEventMask)); + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( iEventMask ); #if defined( HARBOUR_GCC_OS2 ) @@ -706,12 +707,14 @@ static int hb_gt_pca_ReadKey( int iEventMask ) return ch; } -static void hb_gt_pca_Tone( double dFrequency, double dDuration ) +static void hb_gt_pca_Tone( PHB_GT pGT, double dFrequency, double dDuration ) { static double dLastSeconds = 0; double dCurrentSeconds; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_pca_Tone(%lf, %lf)", dFrequency, dDuration)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_pca_Tone(%p, %lf, %lf)", pGT, dFrequency, dDuration)); + + HB_SYMBOL_UNUSED( pGT ); /* Output an ASCII BEL character to cause a sound */ /* but throttle to max once per second, in case of sound */ @@ -732,17 +735,21 @@ static void hb_gt_pca_Tone( double dFrequency, double dDuration ) hb_idleSleep( dDuration / 18.2 ); } -static void hb_gt_pca_Bell( void ) +static void hb_gt_pca_Bell( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_gt_pca_Bell()" ) ); + HB_TRACE(HB_TR_DEBUG, ( "hb_gt_pca_Bell(%p)", pGT ) ); + + HB_SYMBOL_UNUSED( pGT ); hb_gt_pca_termOut( s_szBell, 1 ); hb_gt_pca_termFlush(); } -static char * hb_gt_pca_Version( int iType ) +static char * hb_gt_pca_Version( PHB_GT pGT, int iType ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_pca_Version(%d)", iType ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_pca_Version(%p,%d)", pGT, iType ) ); + + HB_SYMBOL_UNUSED( pGT ); if( iType == 0 ) return HB_GT_DRVNAME( HB_GT_NAME ); @@ -750,9 +757,11 @@ static char * hb_gt_pca_Version( int iType ) return "Harbour Terminal: PC ANSI"; } -static BOOL hb_gt_pca_Suspend( void ) +static BOOL hb_gt_pca_Suspend( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_pca_Suspend()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_pca_Suspend(%p)", pGT ) ); + + HB_SYMBOL_UNUSED( pGT ); #if defined( OS_UNIX_COMPATIBLE ) || defined( __DJGPP__ ) if( s_fRestTTY ) { @@ -764,10 +773,11 @@ static BOOL hb_gt_pca_Suspend( void ) return TRUE; } -static BOOL hb_gt_pca_Resume( void ) +static BOOL hb_gt_pca_Resume( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_pca_Resume()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_pca_Resume(%p)", pGT ) ); + HB_SYMBOL_UNUSED( pGT ); #if defined( OS_UNIX_COMPATIBLE ) || defined( __DJGPP__ ) if( s_fRestTTY ) { @@ -779,11 +789,11 @@ static BOOL hb_gt_pca_Resume( void ) return TRUE; } -static BOOL hb_gt_pca_SetDispCP( char *pszTermCDP, char *pszHostCDP, BOOL fBox ) +static BOOL hb_gt_pca_SetDispCP( PHB_GT pGT, char *pszTermCDP, char *pszHostCDP, BOOL fBox ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_pca_SetDispCP(%s,%s,%d)", pszTermCDP, pszHostCDP, (int) fBox ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_pca_SetDispCP(%p,%s,%s,%d)", pGT, pszTermCDP, pszHostCDP, (int) fBox ) ); - HB_GTSUPER_SETDISPCP( pszTermCDP, pszHostCDP, fBox ); + HB_GTSUPER_SETDISPCP( pGT, pszTermCDP, pszHostCDP, fBox ); #ifndef HB_CDP_SUPPORT_OFF if( !pszHostCDP ) @@ -803,10 +813,11 @@ static BOOL hb_gt_pca_SetDispCP( char *pszTermCDP, char *pszHostCDP, BOOL fBox ) return FALSE; } -static BOOL hb_gt_pca_SetKeyCP( char *pszTermCDP, char *pszHostCDP ) +static BOOL hb_gt_pca_SetKeyCP( PHB_GT pGT, char *pszTermCDP, char *pszHostCDP ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_pca_SetKeyCP(%s,%s)", pszTermCDP, pszHostCDP ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_pca_SetKeyCP(%p,%s,%s)", pGT, pszTermCDP, pszHostCDP ) ); + HB_SYMBOL_UNUSED( pGT ); #ifndef HB_CDP_SUPPORT_OFF if( !pszHostCDP ) pszHostCDP = hb_cdp_page->id; @@ -846,17 +857,17 @@ static BOOL hb_gt_pca_SetKeyCP( char *pszTermCDP, char *pszHostCDP ) return FALSE; } -static void hb_gt_pca_Redraw( int iRow, int iCol, int iSize ) +static void hb_gt_pca_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize ) { BYTE bColor, bAttr; USHORT usChar; int iLen = 0, iColor = 0; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_pca_Redraw(%d, %d, %d)", iRow, iCol, iSize ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_pca_Redraw(%p,%d,%d,%d)", pGT, iRow, iCol, iSize ) ); while( iSize-- ) { - if( !hb_gt_GetScrChar( iRow, iCol + iLen, &bColor, &bAttr, &usChar ) ) + if( !HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol + iLen, &bColor, &bAttr, &usChar ) ) break; if( iLen == 0 ) @@ -886,13 +897,13 @@ static void hb_gt_pca_Redraw( int iRow, int iCol, int iSize ) } } -static void hb_gt_pca_Refresh( void ) +static void hb_gt_pca_Refresh( PHB_GT pGT ) { int iWidth, iHeight, iRow, iCol, iStyle; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_pca_Refresh()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_pca_Refresh(%p)", pGT ) ); - hb_gt_GetSize( &iHeight, &iWidth ); + HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth ); if( s_iLineBufSize == 0 ) { @@ -905,9 +916,9 @@ static void hb_gt_pca_Refresh( void ) s_iLineBufSize = iWidth; } - HB_GTSUPER_REFRESH(); + HB_GTSUPER_REFRESH( pGT ); - hb_gt_GetScrCursor( &iRow, &iCol, &iStyle ); + HB_GTSELF_GETSCRCURSOR( pGT, &iRow, &iCol, &iStyle ); if( iStyle != SC_NONE ) { if( iRow >= 0 && iCol >= 0 && iRow < iHeight && iCol < iWidth ) @@ -919,9 +930,9 @@ static void hb_gt_pca_Refresh( void ) hb_gt_pca_termFlush(); } -static BOOL hb_gt_pca_Info( int iType, PHB_GT_INFO pInfo ) +static BOOL hb_gt_pca_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_pca_Info(%d,%p)", iType, pInfo ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_pca_Info(%p,%d,%p)", pGT, iType, pInfo ) ); switch ( iType ) { @@ -931,7 +942,7 @@ static BOOL hb_gt_pca_Info( int iType, PHB_GT_INFO pInfo ) break; default: - return HB_GTSUPER_INFO( iType, pInfo ); + return HB_GTSUPER_INFO( pGT, iType, pInfo ); } return TRUE; diff --git a/harbour/source/rtl/gtsln/gtsln.c b/harbour/source/rtl/gtsln/gtsln.c index b14b7ed530..2b288ce519 100644 --- a/harbour/source/rtl/gtsln/gtsln.c +++ b/harbour/source/rtl/gtsln/gtsln.c @@ -566,11 +566,11 @@ static int hb_sln_isUTF8( int iStdOut, int iStdIn ) /* *********************************************************************** */ /* I think this function should not be void. It should be BOOL */ -static void hb_gt_sln_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) +static void hb_gt_sln_Init( PHB_GT pGT, FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) { BOOL gt_Inited = FALSE; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_sln_Init(%p,%p,%p)", hFilenoStdin, hFilenoStdout, hFilenoStderr)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_sln_Init(%p,%p,%p,%p)", pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr)); /* stdin && stdout && stderr */ s_hStdIn = hFilenoStdin; @@ -694,21 +694,21 @@ static void hb_gt_sln_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE s_fActive = TRUE; hb_gt_sln_mouse_Init(); - HB_GTSUPER_INIT( hFilenoStdin, hFilenoStdout, hFilenoStderr ); - HB_GTSUPER_RESIZE( SLtt_Screen_Rows, SLtt_Screen_Cols ); - hb_gt_SetFlag( GTI_COMPATBUFFER, FALSE ); - hb_gt_SetFlag( GTI_STDOUTCON, s_fStdOutTTY ); - hb_gt_SetFlag( GTI_STDERRCON, s_fStdErrTTY ); + HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr ); + HB_GTSUPER_RESIZE( pGT, SLtt_Screen_Rows, SLtt_Screen_Cols ); + HB_GTSELF_SETFLAG( pGT, GTI_COMPATBUFFER, FALSE ); + HB_GTSELF_SETFLAG( pGT, GTI_STDOUTCON, s_fStdOutTTY ); + HB_GTSELF_SETFLAG( pGT, GTI_STDERRCON, s_fStdErrTTY ); - hb_gt_SetBlink( TRUE ); - hb_gt_SetPos( SLsmg_get_row(), SLsmg_get_column() ); + HB_GTSELF_SETBLINK( pGT, TRUE ); + HB_GTSELF_SETPOS( pGT, SLsmg_get_row(), SLsmg_get_column() ); } /* *********************************************************************** */ -static void hb_gt_sln_Exit( void ) +static void hb_gt_sln_Exit( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_sln_Exit()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_sln_Exit(%p)", pGT)); /* restore a standard bell frequency and duration */ if( hb_sln_UnderLinuxConsole ) @@ -718,7 +718,7 @@ static void hb_gt_sln_Exit( void ) SLtt_flush_output(); } - hb_gt_Refresh(); + HB_GTSELF_REFRESH( pGT ); hb_gt_sln_mouse_Exit(); /* NOTE: This is incompatible with Clipper - on exit leave a cursor visible */ hb_sln_SetCursorStyle( SC_NORMAL ); @@ -729,15 +729,16 @@ static void hb_gt_sln_Exit( void ) s_fStdInTTY = s_fStdOutTTY = s_fStdErrTTY = s_fActive = FALSE; - HB_GTSUPER_EXIT(); + HB_GTSUPER_EXIT( pGT ); } /* *********************************************************************** */ -static BOOL hb_gt_sln_SetMode( int iRows, int iCols ) +static BOOL hb_gt_sln_SetMode( PHB_GT pGT, int iRows, int iCols ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_sln_SetMode(%d, %d)", iRows, iCols)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_sln_SetMode(%p,%d,%d)", pGT, iRows, iCols)); + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( iRows ); HB_SYMBOL_UNUSED( iCols ); @@ -747,18 +748,20 @@ static BOOL hb_gt_sln_SetMode( int iRows, int iCols ) /* *********************************************************************** */ -static BOOL hb_gt_sln_IsColor( void ) +static BOOL hb_gt_sln_IsColor( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_sln_IsColor()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_sln_IsColor(%p)", pGT)); + + HB_SYMBOL_UNUSED( pGT ); return SLtt_Use_Ansi_Colors; } /* *********************************************************************** */ -static void hb_gt_sln_SetBlink( BOOL fBlink ) +static void hb_gt_sln_SetBlink( PHB_GT pGT, BOOL fBlink ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_sln_SetBlink(%d)", (int) fBlink)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_sln_SetBlink(%p,%d)", pGT, (int) fBlink)); /* * We cannot switch remote terminal between blinking and highlight mode @@ -774,17 +777,19 @@ static void hb_gt_sln_SetBlink( BOOL fBlink ) */ SLtt_Blink_Mode = fBlink ? 1 : 0; - HB_GTSUPER_SETBLINK( fBlink ); + HB_GTSUPER_SETBLINK( pGT, fBlink ); } /* *********************************************************************** */ -static void hb_gt_sln_Tone( double dFrequency, double dDuration ) +static void hb_gt_sln_Tone( PHB_GT pGT, double dFrequency, double dDuration ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_sln_Tone(%lf, %lf)", dFrequency, dDuration)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_sln_Tone(%p,%lf,%lf)", pGT, dFrequency, dDuration)); /* TODO: Implement this for other consoles than linux ? */ + HB_SYMBOL_UNUSED( pGT ); + if( hb_sln_UnderLinuxConsole ) { char escstr[ 64 ]; @@ -812,9 +817,11 @@ static void hb_gt_sln_Tone( double dFrequency, double dDuration ) /* *********************************************************************** */ -static char * hb_gt_sln_Version( int iType ) +static char * hb_gt_sln_Version( PHB_GT pGT, int iType ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_sln_Version()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_sln_Version(%p)", pGT ) ); + + HB_SYMBOL_UNUSED( pGT ); if ( iType == 0 ) return HB_GT_DRVNAME( HB_GT_NAME ); @@ -829,8 +836,10 @@ static char * hb_gt_sln_Version( int iType ) /* *********************************************************************** */ -static BOOL hb_gt_sln_Suspend( void ) +static BOOL hb_gt_sln_Suspend( PHB_GT pGT ) { + HB_SYMBOL_UNUSED( pGT ); + if( ! s_bSuspended ) { if( SLsmg_suspend_smg() != -1 ) @@ -845,8 +854,10 @@ static BOOL hb_gt_sln_Suspend( void ) /* *********************************************************************** */ -static BOOL hb_gt_sln_Resume( void ) +static BOOL hb_gt_sln_Resume( PHB_GT pGT ) { + HB_SYMBOL_UNUSED( pGT ); + if( s_bSuspended && SLsmg_resume_smg() != -1 && hb_sln_Init_Terminal( 1 ) != -1 ) { @@ -862,27 +873,31 @@ static BOOL hb_gt_sln_Resume( void ) /* *********************************************************************** */ -static BOOL hb_gt_sln_PreExt( void ) +static BOOL hb_gt_sln_PreExt( PHB_GT pGT ) { - SLsmg_refresh(); + HB_SYMBOL_UNUSED( pGT ); + + SLsmg_refresh(); #ifdef HAVE_GPM_H - hb_gt_sln_mouse_FixTrash(); + hb_gt_sln_mouse_FixTrash(); #endif - return TRUE; + return TRUE; } /* *********************************************************************** */ -static BOOL hb_gt_sln_PostExt( void ) +static BOOL hb_gt_sln_PostExt( PHB_GT pGT ) { - return TRUE; + HB_SYMBOL_UNUSED( pGT ); + + return TRUE; } /* *********************************************************************** */ -static BOOL hb_gt_sln_Info( int iType, PHB_GT_INFO pInfo ) +static BOOL hb_gt_sln_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_sln_Info(%d,%p)", iType, pInfo ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_sln_Info(%p,%d,%p)", pGT, iType, pInfo ) ); switch ( iType ) { @@ -898,7 +913,7 @@ static BOOL hb_gt_sln_Info( int iType, PHB_GT_INFO pInfo ) break; default: - return HB_GTSUPER_INFO( iType, pInfo ); + return HB_GTSUPER_INFO( pGT, iType, pInfo ); } return TRUE; @@ -907,9 +922,9 @@ static BOOL hb_gt_sln_Info( int iType, PHB_GT_INFO pInfo ) /* *********************************************************************** */ -static BOOL hb_gt_sln_SetDispCP( char * pszTermCDP, char * pszHostCDP, BOOL fBox ) +static BOOL hb_gt_sln_SetDispCP( PHB_GT pGT, char * pszTermCDP, char * pszHostCDP, BOOL fBox ) { - HB_GTSUPER_SETDISPCP( pszTermCDP, pszHostCDP, fBox ); + HB_GTSUPER_SETDISPCP( pGT, pszTermCDP, pszHostCDP, fBox ); #ifndef HB_CDP_SUPPORT_OFF { @@ -932,7 +947,7 @@ static BOOL hb_gt_sln_SetDispCP( char * pszTermCDP, char * pszHostCDP, BOOL fBox /* *********************************************************************** */ -static BOOL hb_gt_sln_SetKeyCP( char * pszTermCDP, char * pszHostCDP ) +static BOOL hb_gt_sln_SetKeyCP( PHB_GT pGT, char * pszTermCDP, char * pszHostCDP ) { #ifndef HB_CDP_SUPPORT_OFF PHB_CODEPAGE cdpTerm = NULL, cdpHost = NULL; @@ -951,14 +966,16 @@ static BOOL hb_gt_sln_SetKeyCP( char * pszTermCDP, char * pszHostCDP ) HB_SYMBOL_UNUSED( pszTermCDP ); HB_SYMBOL_UNUSED( pszHostCDP ); #endif + HB_SYMBOL_UNUSED( pGT ); + return TRUE; } /* *********************************************************************** */ -static void hb_gt_sln_Redraw( int iRow, int iCol, int iSize ) +static void hb_gt_sln_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_sln_Redraw(%d, %d, %d)", iRow, iCol, iSize ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_sln_Redraw(%p,%d,%d,%d)", pGT, iRow, iCol, iSize ) ); if( s_fActive ) { @@ -968,7 +985,7 @@ static void hb_gt_sln_Redraw( int iRow, int iCol, int iSize ) while( iSize-- > 0 ) { - if( !hb_gt_GetScrChar( iRow, iCol, &bColor, &bAttr, &usChar ) ) + if( !HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol, &bColor, &bAttr, &usChar ) ) break; SLsmg_gotorc( iRow, iCol ); HB_SLN_BUILD_CHAR( SLchar, usChar & 0xff, bColor, bAttr ); @@ -980,16 +997,16 @@ static void hb_gt_sln_Redraw( int iRow, int iCol, int iSize ) /* *********************************************************************** */ -static void hb_gt_sln_Refresh( void ) +static void hb_gt_sln_Refresh( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_sln_Refresh()") ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_sln_Refresh(%p)", pGT ) ); - HB_GTSUPER_REFRESH(); + HB_GTSUPER_REFRESH( pGT ); if( s_fActive ) { int iRow, iCol, iStyle; - hb_gt_GetScrCursor( &iRow, &iCol, &iStyle ); + HB_GTSELF_GETSCRCURSOR( pGT, &iRow, &iCol, &iStyle ); if( iStyle != SC_NONE && ( iRow < 0 || iCol < 0 || iRow >= SLtt_Screen_Rows || iCol >= SLtt_Screen_Cols ) ) iStyle = SC_NONE; diff --git a/harbour/source/rtl/gtsln/gtsln.h b/harbour/source/rtl/gtsln/gtsln.h index 7a4e0ee49f..392f43d1d3 100644 --- a/harbour/source/rtl/gtsln/gtsln.h +++ b/harbour/source/rtl/gtsln/gtsln.h @@ -233,17 +233,17 @@ extern volatile BOOL hb_sln_bScreen_Size_Changed; extern int hb_sln_Init_Terminal( int phase ); -extern int hb_gt_sln_ReadKey( int iEventMask ); +extern int hb_gt_sln_ReadKey( PHB_GT pGT, int iEventMask ); extern void hb_gt_sln_mouse_Init( void ); extern void hb_gt_sln_mouse_Exit( void ); -extern BOOL hb_gt_sln_mouse_IsPresent( void ); -extern void hb_gt_sln_mouse_Show( void ); -extern void hb_gt_sln_mouse_Hide( void ); -extern void hb_gt_sln_mouse_GetPos( int * piRow, int * piCol ); -extern void hb_gt_sln_mouse_SetPos( int iRow, int iCol ); -extern int hb_gt_sln_mouse_CountButton( void ); -extern BOOL hb_gt_sln_mouse_ButtonState( int iButton ); +extern BOOL hb_gt_sln_mouse_IsPresent( PHB_GT pGT ); +extern void hb_gt_sln_mouse_Show( PHB_GT pGT ); +extern void hb_gt_sln_mouse_Hide( PHB_GT pGT ); +extern void hb_gt_sln_mouse_GetPos( PHB_GT pGT, int * piRow, int * piCol ); +extern void hb_gt_sln_mouse_SetPos( PHB_GT pGT, int iRow, int iCol ); +extern int hb_gt_sln_mouse_CountButton( PHB_GT pGT ); +extern BOOL hb_gt_sln_mouse_ButtonState( PHB_GT pGT, int iButton ); extern void hb_gt_sln_mouse_FixTrash( void ); extern int hb_gt_sln_mouse_Inkey( int iEventMask, BOOL fCheckNew ); diff --git a/harbour/source/rtl/gtsln/kbsln.c b/harbour/source/rtl/gtsln/kbsln.c index c378686e76..716793d452 100644 --- a/harbour/source/rtl/gtsln/kbsln.c +++ b/harbour/source/rtl/gtsln/kbsln.c @@ -307,14 +307,14 @@ int hb_sln_Init_Terminal( int phase ) /* *********************************************************************** */ -int hb_gt_sln_ReadKey( int iEventMask ) +int hb_gt_sln_ReadKey( PHB_GT pGT, int iEventMask ) { static int InDeadState = FALSE; unsigned int ch, tmp, kbdflags; BOOL fInput; int iKey; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_sln_ReadKey(%d)", (int) iEventMask)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_sln_ReadKey(%p,%d)", pGT, (int) iEventMask)); /* user AbortKey break */ if( SLKeyBoard_Quit == 1 ) @@ -331,7 +331,7 @@ int hb_gt_sln_ReadKey( int iEventMask ) /* TODO: we need here some kind of screen redrawing */ /*SLsmg_refresh();*/ - hb_gt_Resize( SLtt_Screen_Rows, SLtt_Screen_Cols ); + HB_GTSELF_RESIZE( pGT, SLtt_Screen_Rows, SLtt_Screen_Cols ); } fInput = SLang_input_pending( 0 ) != 0; diff --git a/harbour/source/rtl/gtsln/mousesln.c b/harbour/source/rtl/gtsln/mousesln.c index ae7dace73b..e5613bc60d 100644 --- a/harbour/source/rtl/gtsln/mousesln.c +++ b/harbour/source/rtl/gtsln/mousesln.c @@ -138,19 +138,19 @@ static void hb_sln_CheckDoubleClick() { if ( TIMEVAL_LESS( evtTime, mLeftDblckTime ) ) s_usMouseState |= M_BUTTON_LDBLCK; - TIMEVAL_ADD( mLeftDblckTime, evtTime, hb_mouse_GetDoubleClickSpeed() ); + TIMEVAL_ADD( mLeftDblckTime, evtTime, hb_mouseGetDoubleClickSpeed() ); } if( usNewButtons & M_BUTTON_MIDDLE ) { if ( TIMEVAL_LESS( evtTime, mMiddleDblckTime ) ) s_usMouseState |= M_BUTTON_MDBLCK; - TIMEVAL_ADD( mMiddleDblckTime, evtTime, hb_mouse_GetDoubleClickSpeed() ); + TIMEVAL_ADD( mMiddleDblckTime, evtTime, hb_mouseGetDoubleClickSpeed() ); } if( usNewButtons & M_BUTTON_RIGHT ) { if ( TIMEVAL_LESS( evtTime, mRightDblckTime ) ) s_usMouseState |= M_BUTTON_RDBLCK; - TIMEVAL_ADD( mRightDblckTime, evtTime, hb_mouse_GetDoubleClickSpeed() ); + TIMEVAL_ADD( mRightDblckTime, evtTime, hb_mouseGetDoubleClickSpeed() ); } } } @@ -429,15 +429,19 @@ void hb_gt_sln_mouse_Exit( void ) /* *********************************************************************** */ -BOOL hb_gt_sln_mouse_IsPresent( void ) +BOOL hb_gt_sln_mouse_IsPresent( PHB_GT pGT ) { + HB_SYMBOL_UNUSED( pGT ); + return s_bMousePresent; } /* *********************************************************************** */ -void hb_gt_sln_mouse_Show( void ) +void hb_gt_sln_mouse_Show( PHB_GT pGT ) { + HB_SYMBOL_UNUSED( pGT ); + #ifdef HAVE_GPM_H gpm_visiblepointer = 1; if( hb_sln_UnderLinuxConsole && s_bMousePresent ) @@ -448,8 +452,10 @@ void hb_gt_sln_mouse_Show( void ) /* *********************************************************************** */ -void hb_gt_sln_mouse_Hide( void ) +void hb_gt_sln_mouse_Hide( PHB_GT pGT ) { + HB_SYMBOL_UNUSED( pGT ); + #ifdef HAVE_GPM_H gpm_visiblepointer = 0; #endif @@ -458,16 +464,20 @@ void hb_gt_sln_mouse_Hide( void ) /* *********************************************************************** */ -void hb_gt_sln_mouse_GetPos( int * piRow, int * piCol ) +void hb_gt_sln_mouse_GetPos( PHB_GT pGT, int * piRow, int * piCol ) { + HB_SYMBOL_UNUSED( pGT ); + *piRow = s_iMouseRow; *piCol = s_iMouseCol; } /* *********************************************************************** */ -void hb_gt_sln_mouse_SetPos( int iRow, int iCol ) +void hb_gt_sln_mouse_SetPos( PHB_GT pGT, int iRow, int iCol ) { + HB_SYMBOL_UNUSED( pGT ); + /* it does really nothing */ s_iMouseRow = iRow; s_iMouseCol = iCol; @@ -480,8 +490,10 @@ void hb_gt_sln_mouse_SetPos( int iRow, int iCol ) /* *********************************************************************** */ -BOOL hb_gt_sln_mouse_ButtonState( int iButton ) +BOOL hb_gt_sln_mouse_ButtonState( PHB_GT pGT, int iButton ) { + HB_SYMBOL_UNUSED( pGT ); + switch( iButton ) { case 0: @@ -497,9 +509,11 @@ BOOL hb_gt_sln_mouse_ButtonState( int iButton ) /* *********************************************************************** */ -int hb_gt_sln_mouse_CountButton( void ) +int hb_gt_sln_mouse_CountButton( PHB_GT pGT ) { - return( s_iMouseButtons ); + HB_SYMBOL_UNUSED( pGT ); + + return s_iMouseButtons; } /* *********************************************************************** */ diff --git a/harbour/source/rtl/gtstd/gtstd.c b/harbour/source/rtl/gtstd/gtstd.c index 4d62f0f8d4..0cce12aafb 100644 --- a/harbour/source/rtl/gtstd/gtstd.c +++ b/harbour/source/rtl/gtstd/gtstd.c @@ -168,9 +168,9 @@ static void hb_gt_std_newLine( void ) } -static void hb_gt_std_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) +static void hb_gt_std_Init( PHB_GT pGT, FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_std_Init(%p,%p,%p)", hFilenoStdin, hFilenoStdout, hFilenoStderr)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_std_Init(%p,%p,%p,%p)", pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr)); s_hFilenoStdin = hFilenoStdin; s_hFilenoStdout = hFilenoStdout; @@ -189,7 +189,7 @@ static void hb_gt_std_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE s_ulCrLf = strlen( ( char * ) s_szCrLf ); hb_fsSetDevMode( s_hFilenoStdout, FD_BINARY ); - HB_GTSUPER_INIT( hFilenoStdin, hFilenoStdout, hFilenoStderr ); + 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 ) @@ -233,7 +233,7 @@ static void hb_gt_std_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE if( ioctl( hFilenoStdout, TIOCGWINSZ, ( char * ) &win ) != -1 ) { - HB_GTSUPER_RESIZE( win.ws_row, win.ws_col ); + HB_GTSUPER_RESIZE( pGT, win.ws_row, win.ws_col ); } } #elif defined( HB_WIN32_IO ) && ! defined( HB_WINCE ) @@ -242,17 +242,17 @@ static void hb_gt_std_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE SetConsoleMode( ( HANDLE ) hb_fsGetOsHandle( s_hFilenoStdin ), 0x0000 ); } #endif - hb_gt_SetFlag( GTI_STDOUTCON, s_bStdoutConsole ); - hb_gt_SetFlag( GTI_STDERRCON, s_bStderrConsole ); + HB_GTSELF_SETFLAG( pGT, GTI_STDOUTCON, s_bStdoutConsole ); + HB_GTSELF_SETFLAG( pGT, GTI_STDERRCON, s_bStderrConsole ); } -static void hb_gt_std_Exit( void ) +static void hb_gt_std_Exit( PHB_GT pGT ) { int iRow, iCol; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_std_Exit()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_std_Exit(%p)", pGT)); - hb_gt_Refresh(); + HB_GTSELF_REFRESH( pGT ); /* update cursor position on exit */ if( s_bStdoutConsole && s_iLastCol > 0 ) @@ -261,11 +261,11 @@ static void hb_gt_std_Exit( void ) ++s_iRow; } - hb_gt_GetPos( &iRow, &iCol ); + HB_GTSELF_GETPOS( pGT, &iRow, &iCol ); while( ++s_iRow <= iRow ) hb_gt_std_newLine(); - HB_GTSUPER_EXIT(); + HB_GTSUPER_EXIT( pGT ); #if defined( OS_UNIX_COMPATIBLE ) if( s_fRestTTY ) @@ -279,12 +279,13 @@ static void hb_gt_std_Exit( void ) s_bStdinConsole = s_bStdoutConsole = s_bStderrConsole = FALSE; } -static int hb_gt_std_ReadKey( int iEventMask ) +static int hb_gt_std_ReadKey( PHB_GT pGT, int iEventMask ) { int ch = 0; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_std_ReadKey(%d)", iEventMask)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_std_ReadKey(%p,%d)", pGT, iEventMask)); + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( iEventMask ); #if defined( _MSC_VER ) && !defined( HB_WINCE ) @@ -332,19 +333,23 @@ static int hb_gt_std_ReadKey( int iEventMask ) return ch; } -static BOOL hb_gt_std_IsColor( void ) +static BOOL hb_gt_std_IsColor( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_std_IsColor()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_std_IsColor(%p)", pGT)); + + HB_SYMBOL_UNUSED( pGT ); return FALSE; } -static void hb_gt_std_Tone( double dFrequency, double dDuration ) +static void hb_gt_std_Tone( PHB_GT pGT, double dFrequency, double dDuration ) { static double dLastSeconds = 0; double dCurrentSeconds; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_std_Tone(%lf, %lf)", dFrequency, dDuration)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_std_Tone(%p,%lf,%lf)", pGT, dFrequency, dDuration)); + + HB_SYMBOL_UNUSED( pGT ); /* Output an ASCII BEL character to cause a sound */ /* but throttle to max once per second, in case of sound */ @@ -364,16 +369,20 @@ static void hb_gt_std_Tone( double dFrequency, double dDuration ) hb_idleSleep( dDuration / 18.2 ); } -static void hb_gt_std_Bell( void ) +static void hb_gt_std_Bell( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_gt_std_Bell()" ) ); + HB_TRACE(HB_TR_DEBUG, ( "hb_gt_std_Bell(%p)", pGT ) ); + + HB_SYMBOL_UNUSED( pGT ); hb_gt_std_termOut( s_szBell, 1 ); } -static char * hb_gt_std_Version( int iType ) +static char * hb_gt_std_Version( PHB_GT pGT, int iType ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Version(%d)", iType ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Version(%p,%d)", pGT, iType ) ); + + HB_SYMBOL_UNUSED( pGT ); if( iType == 0 ) return HB_GT_DRVNAME( HB_GT_NAME ); @@ -381,9 +390,12 @@ static char * hb_gt_std_Version( int iType ) return "Harbour Terminal: Standard stream console"; } -static BOOL hb_gt_std_Suspend( void ) +static BOOL hb_gt_std_Suspend( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Suspend()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Suspend(%p)", pGT ) ); + + HB_SYMBOL_UNUSED( pGT ); + #if defined( OS_UNIX_COMPATIBLE ) if( s_fRestTTY ) { @@ -393,9 +405,11 @@ static BOOL hb_gt_std_Suspend( void ) return TRUE; } -static BOOL hb_gt_std_Resume( void ) +static BOOL hb_gt_std_Resume( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Resume()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Resume(%p)", pGT ) ); + + HB_SYMBOL_UNUSED( pGT ); #if defined( OS_UNIX_COMPATIBLE ) if( s_fRestTTY ) @@ -406,35 +420,35 @@ static BOOL hb_gt_std_Resume( void ) return TRUE; } -static void hb_gt_std_Scroll( int iTop, int iLeft, int iBottom, int iRight, +static void hb_gt_std_Scroll( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE bColor, BYTE bChar, int iRows, int iCols ) { int iHeight, iWidth; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Scroll(%d,%d,%d,%d,%d,%d,%d,%d)", iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Scroll(%p,%d,%d,%d,%d,%d,%d,%d,%d)", pGT, iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols ) ); /* Provide some basic scroll support for full screen */ - hb_gt_GetSize( &iHeight, &iWidth ); + HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth ); if( iCols == 0 && iRows > 0 && iTop == 0 && iLeft == 0 && iBottom >= iHeight - 1 && iRight >= iWidth - 1 ) { /* scroll up the internal screen buffer */ - HB_GTSUPER_SCROLLUP( iRows, bColor, bChar ); + HB_GTSUPER_SCROLLUP( pGT, iRows, bColor, bChar ); /* update our internal row position */ s_iRow -= iRows; if( s_iRow < 0 ) s_iRow = 0; } else - HB_GTSUPER_SCROLL( iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols ); + HB_GTSUPER_SCROLL( pGT, iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols ); } -static BOOL hb_gt_std_SetDispCP( char *pszTermCDP, char *pszHostCDP, BOOL fBox ) +static BOOL hb_gt_std_SetDispCP( PHB_GT pGT, char *pszTermCDP, char *pszHostCDP, BOOL fBox ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_SetDispCP(%s,%s,%d)", pszTermCDP, pszHostCDP, (int) fBox ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_SetDispCP(%p,%s,%s,%d)", pGT, pszTermCDP, pszHostCDP, (int) fBox ) ); - HB_GTSUPER_SETDISPCP( pszTermCDP, pszHostCDP, fBox ); + HB_GTSUPER_SETDISPCP( pGT, pszTermCDP, pszHostCDP, fBox ); #ifndef HB_CDP_SUPPORT_OFF if( !pszHostCDP ) @@ -454,9 +468,11 @@ static BOOL hb_gt_std_SetDispCP( char *pszTermCDP, char *pszHostCDP, BOOL fBox ) return FALSE; } -static BOOL hb_gt_std_SetKeyCP( char *pszTermCDP, char *pszHostCDP ) +static BOOL hb_gt_std_SetKeyCP( PHB_GT pGT, char *pszTermCDP, char *pszHostCDP ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_SetKeyCP(%s,%s)", pszTermCDP, pszHostCDP ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_SetKeyCP(%p,%s,%s)", pGT, pszTermCDP, pszHostCDP ) ); + + HB_SYMBOL_UNUSED( pGT ); #ifndef HB_CDP_SUPPORT_OFF if( !pszHostCDP ) @@ -497,7 +513,7 @@ static BOOL hb_gt_std_SetKeyCP( char *pszTermCDP, char *pszHostCDP ) return FALSE; } -static void hb_gt_std_DispLine( int iRow ) +static void hb_gt_std_DispLine( PHB_GT pGT, int iRow ) { BYTE bColor, bAttr; USHORT usChar; @@ -505,7 +521,7 @@ static void hb_gt_std_DispLine( int iRow ) for( iCol = 0; iCol < s_iLineBufSize; ++iCol ) { - if( !hb_gt_GetScrChar( iRow, iCol, &bColor, &bAttr, &usChar ) ) + if( !HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol, &bColor, &bAttr, &usChar ) ) break; if( usChar < 32 || usChar == 127 ) usChar = '.'; @@ -520,13 +536,13 @@ static void hb_gt_std_DispLine( int iRow ) s_iRow = iRow; } -static void hb_gt_std_Redraw( int iRow, int iCol, int iSize ) +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; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Redraw(%d, %d, %d)", iRow, iCol, iSize ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Redraw(%p,%d,%d,%d)", pGT, iRow, iCol, iSize ) ); iLineFeed = iBackSpace = 0; @@ -560,7 +576,7 @@ static void hb_gt_std_Redraw( int iRow, int iCol, int iSize ) iMin = iLineFeed > 0 || s_iLastCol <= iCol ? 0 : s_iLastCol - iCol; while( iSize > iMin && - hb_gt_GetScrChar( iRow, iCol + iSize - 1, &bColor, &bAttr, &usChar ) ) + HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol + iSize - 1, &bColor, &bAttr, &usChar ) ) { if( usChar != ' ' ) break; @@ -585,7 +601,7 @@ static void hb_gt_std_Redraw( int iRow, int iCol, int iSize ) s_bFullRedraw = TRUE; } for( i = s_iRow + 1; i < iRow; ++i ) - hb_gt_std_DispLine( i ); + hb_gt_std_DispLine( pGT, i ); iLineFeed = 1; } @@ -602,7 +618,7 @@ static void hb_gt_std_Redraw( int iRow, int iCol, int iSize ) for( iLen = 0; iLen < iSize; ++iLen ) { - if( !hb_gt_GetScrChar( iRow, iCol, &bColor, &bAttr, &usChar ) ) + if( !HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol, &bColor, &bAttr, &usChar ) ) break; if( usChar < 32 || usChar == 127 ) usChar = '.'; @@ -625,13 +641,13 @@ static void hb_gt_std_Redraw( int iRow, int iCol, int iSize ) } } -static void hb_gt_std_Refresh( void ) +static void hb_gt_std_Refresh( PHB_GT pGT ) { int iHeight, iWidth; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Refresh()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Refresh(%p)", pGT ) ); - hb_gt_GetSize( &iHeight, &iWidth ); + HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth ); if( s_iLineBufSize == 0 ) { s_sLineBuf = ( BYTE * ) hb_xgrab( iWidth ); @@ -643,7 +659,7 @@ static void hb_gt_std_Refresh( void ) s_iLineBufSize = iWidth; } s_bFullRedraw = FALSE; - HB_GTSUPER_REFRESH(); + HB_GTSUPER_REFRESH( pGT ); if( s_bFullRedraw ) { int i; @@ -651,14 +667,14 @@ static void hb_gt_std_Refresh( void ) if( s_iRow < iHeight - 1 ) { for( i = s_iRow + 1; i < iHeight; ++i ) - hb_gt_std_DispLine( i ); + hb_gt_std_DispLine( pGT, i ); } } } -static BOOL hb_gt_std_Info( int iType, PHB_GT_INFO pInfo ) +static BOOL hb_gt_std_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Info(%d,%p)", iType, pInfo ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Info(%p,%d,%p)", pGT, iType, pInfo ) ); switch ( iType ) { @@ -668,7 +684,7 @@ static BOOL hb_gt_std_Info( int iType, PHB_GT_INFO pInfo ) break; default: - return HB_GTSUPER_INFO( iType, pInfo ); + return HB_GTSUPER_INFO( pGT, iType, pInfo ); } return TRUE; diff --git a/harbour/source/rtl/gttrm/gttrm.c b/harbour/source/rtl/gttrm/gttrm.c index 4dbe43fe27..3f23241acb 100644 --- a/harbour/source/rtl/gttrm/gttrm.c +++ b/harbour/source/rtl/gttrm/gttrm.c @@ -247,7 +247,7 @@ typedef struct { int fd; int mode; int status; - void *data; + void *cargo; int (*eventFunc) (int, int, void*); } evtFD; @@ -292,8 +292,13 @@ typedef struct { const char * seq; } keySeq; -typedef struct +#define HB_GTTRM_PTR struct _HB_GTTRM * +#define HB_GTTRM_GET(p) ( ( PHB_GTTRM ) HB_GTLOCAL( p ) ) + +typedef struct _HB_GTTRM { + PHB_GT pGT; + FHANDLE hFileno; FHANDLE hFilenoStdin; FHANDLE hFilenoStdout; @@ -333,9 +338,8 @@ typedef struct int terminal_type; #if defined( OS_UNIX_COMPATIBLE ) - volatile BOOL fWinSizeChangeFlag; - volatile BOOL fRestTTY; struct termios saved_TIO, curr_TIO; + BOOL fRestTTY; #endif double dToneSeconds; @@ -367,21 +371,25 @@ typedef struct /* terminal functions */ - void (* Init) ( void ); - void (* Exit) ( void ); - void (* SetTermMode) ( int ); - BOOL (* GetCursorPos) ( int *, int * ); - void (* SetCursorPos) ( int , int ); - void (* SetCursorStyle) ( int ); - void (* SetAttributes) ( int ); - BOOL (* SetMode) ( int *, int * ); - int (* GetAcsc) ( unsigned char ); - void (* Tone) ( double, double ); - void (* Bell) ( void ); + void (* Init) ( HB_GTTRM_PTR ); + void (* Exit) ( HB_GTTRM_PTR ); + void (* SetTermMode) ( HB_GTTRM_PTR, int ); + BOOL (* GetCursorPos) ( HB_GTTRM_PTR, int *, int * ); + void (* SetCursorPos) ( HB_GTTRM_PTR, int , int ); + void (* SetCursorStyle) ( HB_GTTRM_PTR, int ); + void (* SetAttributes) ( HB_GTTRM_PTR, int ); + BOOL (* SetMode) ( HB_GTTRM_PTR, int *, int * ); + int (* GetAcsc) ( HB_GTTRM_PTR, unsigned char ); + void (* Tone) ( HB_GTTRM_PTR, double, double ); + void (* Bell) ( HB_GTTRM_PTR ); const char * szAcsc; -} HB_TERM_STATE; +} HB_TERM_STATE, HB_GTTRM, * PHB_GTTRM; -static HB_TERM_STATE s_termState; +/* static variables use by signal handler */ +#if defined( OS_UNIX_COMPATIBLE ) + static volatile BOOL s_WinSizeChangeFlag = FALSE; + static volatile BOOL s_fRestTTY = FALSE; +#endif /* save old hilit tracking & enable mouse tracking */ static const char * s_szMouseOn = "\033[?1001s\033[?1002h"; @@ -596,22 +604,22 @@ static void sig_handler( int iSigNo ) switch( iSigNo ) { case SIGCHLD: - while( ( pid = waitpid( -1, &stat, WNOHANG ) ) > 0 ) ; + while( ( pid = waitpid( -1, &stat, WNOHANG ) ) > 0 ) { ; } break; case SIGWINCH: - s_termState.fWinSizeChangeFlag = TRUE; + s_WinSizeChangeFlag = TRUE; break; case SIGINT: - /* s_termState.InetrruptFlag = TRUE; */ + /* s_InetrruptFlag = TRUE; */ break; case SIGQUIT: - /* s_termState.BreakFlag = TRUE; */ + /* s_BreakFlag = TRUE; */ break; case SIGTSTP: - /* s_termState.DebugFlag = TRUE; */ + /* s_DebugFlag = TRUE; */ break; case SIGTTOU: - s_termState.fRestTTY = FALSE; + s_fRestTTY = FALSE; break; } errno = e; @@ -641,21 +649,23 @@ static void set_signals( void ) #endif -static int hb_gt_trm_getSize( int * piRows, int * piCols ) +static int hb_gt_trm_getSize( PHB_GTTRM pTerm, int * piRows, int * piCols ) { *piRows = *piCols = 0; #if defined( OS_UNIX_COMPATIBLE ) - if( s_termState.fOutTTY ) + if( pTerm->fOutTTY ) { struct winsize win; - if( ioctl( s_termState.hFileno, TIOCGWINSZ, ( char * ) &win ) != -1 ) + if( ioctl( pTerm->hFileno, TIOCGWINSZ, ( char * ) &win ) != -1 ) { *piRows = win.ws_row; *piCols = win.ws_col; } } +#else + HB_SYMBOL_UNUSED( pTerm ); #endif if( *piRows <= 0 || *piCols <= 0 ) @@ -670,50 +680,50 @@ static int hb_gt_trm_getSize( int * piRows, int * piCols ) return *piRows > 0 && *piCols > 0; } -static void hb_gt_trm_termFlush( void ) +static void hb_gt_trm_termFlush( PHB_GTTRM pTerm ) { - if( s_termState.iOutBufIndex > 0 ) + if( pTerm->iOutBufIndex > 0 ) { - hb_fsWriteLarge( s_termState.hFileno, s_termState.pOutBuf, s_termState.iOutBufIndex ); - s_termState.iOutBufIndex = 0; + hb_fsWriteLarge( pTerm->hFileno, pTerm->pOutBuf, pTerm->iOutBufIndex ); + pTerm->iOutBufIndex = 0; } } -static void hb_gt_trm_termOut( const BYTE * pStr, int iLen ) +static void hb_gt_trm_termOut( PHB_GTTRM pTerm, const BYTE * pStr, int iLen ) { - if( s_termState.iOutBufSize ) + if( pTerm->iOutBufSize ) { int i; while( iLen > 0 ) { - if( s_termState.iOutBufSize == s_termState.iOutBufIndex ) - hb_gt_trm_termFlush(); - i = s_termState.iOutBufSize - s_termState.iOutBufIndex; + if( pTerm->iOutBufSize == pTerm->iOutBufIndex ) + hb_gt_trm_termFlush( pTerm ); + i = pTerm->iOutBufSize - pTerm->iOutBufIndex; if( i > iLen ) i = iLen; - memcpy( s_termState.pOutBuf + s_termState.iOutBufIndex, pStr, i ); - s_termState.iOutBufIndex += i; + memcpy( pTerm->pOutBuf + pTerm->iOutBufIndex, pStr, i ); + pTerm->iOutBufIndex += i; pStr += i; iLen -= i; } } } -static void hb_gt_trm_termOutTrans( BYTE * pStr, int iLen, int iAttr ) +static void hb_gt_trm_termOutTrans( PHB_GTTRM pTerm, BYTE * pStr, int iLen, int iAttr ) { - if( s_termState.iOutBufSize ) + if( pTerm->iOutBufSize ) { #ifdef HB_CDP_SUPPORT_OFF HB_SYMBOL_UNUSED( iAttr ); #else PHB_CODEPAGE cdp = NULL; - if( s_termState.fUTF8 ) + if( pTerm->fUTF8 ) { - if( ( iAttr & HB_GTTRM_ATTR_ACSC ) && s_termState.cdpEN ) - cdp = s_termState.cdpEN; - else if( s_termState.cdpHost ) - cdp = s_termState.cdpHost; + if( ( iAttr & HB_GTTRM_ATTR_ACSC ) && pTerm->cdpEN ) + cdp = pTerm->cdpEN; + else if( pTerm->cdpHost ) + cdp = pTerm->cdpHost; else cdp = hb_cdp_page; } @@ -722,16 +732,16 @@ static void hb_gt_trm_termOutTrans( BYTE * pStr, int iLen, int iAttr ) { while( iLen > 0 ) { - int i = ( s_termState.iOutBufSize - s_termState.iOutBufIndex ) >> 2; + int i = ( pTerm->iOutBufSize - pTerm->iOutBufIndex ) >> 2; if( i < 4 ) { - hb_gt_trm_termFlush(); - i = s_termState.iOutBufSize >> 2; + hb_gt_trm_termFlush( pTerm ); + i = pTerm->iOutBufSize >> 2; } if( i > iLen ) i = iLen; - s_termState.iOutBufIndex += hb_cdpStrnToUTF8( cdp, TRUE, pStr, i, - s_termState.pOutBuf + s_termState.iOutBufIndex ); + pTerm->iOutBufIndex += hb_cdpStrnToUTF8( cdp, TRUE, pStr, i, + pTerm->pOutBuf + pTerm->iOutBufIndex ); pStr += i; iLen -= i; } @@ -739,7 +749,7 @@ static void hb_gt_trm_termOutTrans( BYTE * pStr, int iLen, int iAttr ) else #endif { - hb_gt_trm_termOut( pStr, iLen ); + hb_gt_trm_termOut( pTerm, pStr, iLen ); } } } @@ -750,8 +760,8 @@ static void hb_gt_trm_termOutTrans( BYTE * pStr, int iLen, int iAttr ) * KEYBOARD and MOUSE */ -static int add_efds( int fd, int mode, - int ( *eventFunc ) ( int, int, void * ), void *data ) +static int add_efds( PHB_GTTRM pTerm, int fd, int mode, + int ( *eventFunc ) ( int, int, void * ), void *cargo ) { evtFD *pefd = NULL; int i; @@ -772,74 +782,74 @@ static int add_efds( int fd, int mode, } #endif - for( i = 0; i < s_termState.efds_no && !pefd; i++ ) - if( s_termState.event_fds[i]->fd == fd ) - pefd = s_termState.event_fds[i]; + for( i = 0; i < pTerm->efds_no && !pefd; i++ ) + if( pTerm->event_fds[i]->fd == fd ) + pefd = pTerm->event_fds[i]; if( pefd ) { pefd->mode = mode; - pefd->data = data; + pefd->cargo = cargo; pefd->eventFunc = eventFunc; pefd->status = EVTFDSTAT_RUN; } else { - if( s_termState.efds_size <= s_termState.efds_no ) + if( pTerm->efds_size <= pTerm->efds_no ) { - if( s_termState.event_fds == NULL ) - s_termState.event_fds = ( evtFD ** ) - hb_xgrab( ( s_termState.efds_size += 10 ) * sizeof( evtFD * ) ); + if( pTerm->event_fds == NULL ) + pTerm->event_fds = ( evtFD ** ) + hb_xgrab( ( pTerm->efds_size += 10 ) * sizeof( evtFD * ) ); else - s_termState.event_fds = ( evtFD ** ) - hb_xrealloc( s_termState.event_fds, - ( s_termState.efds_size += 10 ) * sizeof( evtFD * ) ); + pTerm->event_fds = ( evtFD ** ) + hb_xrealloc( pTerm->event_fds, + ( pTerm->efds_size += 10 ) * sizeof( evtFD * ) ); } pefd = ( evtFD * ) hb_xgrab( sizeof( evtFD ) ); pefd->fd = fd; pefd->mode = mode; - pefd->data = data; + pefd->cargo = cargo; pefd->eventFunc = eventFunc; pefd->status = EVTFDSTAT_RUN; - s_termState.event_fds[s_termState.efds_no++] = pefd; + pTerm->event_fds[pTerm->efds_no++] = pefd; } return fd; } #ifdef HAVE_GPM_H -static void del_efds( int fd ) +static void del_efds( PHB_GTTRM pTerm, int fd ) { int i, n = -1; - for( i = 0; i < s_termState.efds_no && n == -1; i++ ) - if( s_termState.event_fds[i]->fd == fd ) + for( i = 0; i < pTerm->efds_no && n == -1; i++ ) + if( pTerm->event_fds[i]->fd == fd ) n = i; if( n != -1 ) { - hb_xfree( s_termState.event_fds[n] ); - s_termState.efds_no--; - for( i = n; i < s_termState.efds_no; i++ ) - s_termState.event_fds[i] = s_termState.event_fds[i + 1]; + hb_xfree( pTerm->event_fds[n] ); + pTerm->efds_no--; + for( i = n; i < pTerm->efds_no; i++ ) + pTerm->event_fds[i] = pTerm->event_fds[i + 1]; } } #endif -static void del_all_efds( void ) +static void del_all_efds( PHB_GTTRM pTerm ) { int i; - if( s_termState.event_fds != NULL ) + if( pTerm->event_fds != NULL ) { - for( i = 0; i < s_termState.efds_no; i++ ) - hb_xfree( s_termState.event_fds[i] ); + for( i = 0; i < pTerm->efds_no; i++ ) + hb_xfree( pTerm->event_fds[i] ); - hb_xfree( s_termState.event_fds ); + hb_xfree( pTerm->event_fds ); - s_termState.event_fds = NULL; - s_termState.efds_no = s_termState.efds_size = 0; + pTerm->event_fds = NULL; + pTerm->efds_no = pTerm->efds_size = 0; } } @@ -930,9 +940,9 @@ static int getMouseKey( mouseEvent * mEvt ) return nKey; } -static void chk_mevtdblck( mouseEvent * mEvt ) +static void chk_mevtdblck( PHB_GTTRM pTerm ) { - int newbuttons = ( mEvt->buttonstate & ~mEvt->lbuttons ) & M_BUTTON_KEYMASK; + int newbuttons = ( pTerm->mLastEvt.buttonstate & ~pTerm->mLastEvt.lbuttons ) & M_BUTTON_KEYMASK; if( newbuttons != 0 ) { @@ -945,26 +955,29 @@ static void chk_mevtdblck( mouseEvent * mEvt ) TIMEVAL_GET( tv ); if( newbuttons & M_BUTTON_LEFT ) { - if( TIMEVAL_LESS( tv, mEvt->BL_time ) ) - mEvt->buttonstate |= M_BUTTON_LDBLCK; - TIMEVAL_ADD( mEvt->BL_time, tv, hb_mouse_GetDoubleClickSpeed() ); + if( TIMEVAL_LESS( tv, pTerm->mLastEvt.BL_time ) ) + pTerm->mLastEvt.buttonstate |= M_BUTTON_LDBLCK; + TIMEVAL_ADD( pTerm->mLastEvt.BL_time, tv, + HB_GTSELF_MOUSEGETDOUBLECLICKSPEED( pTerm->pGT ) ); } if( newbuttons & M_BUTTON_MIDDLE ) { - if( TIMEVAL_LESS( tv, mEvt->BM_time ) ) - mEvt->buttonstate |= M_BUTTON_MDBLCK; - TIMEVAL_ADD( mEvt->BM_time, tv, hb_mouse_GetDoubleClickSpeed() ); + if( TIMEVAL_LESS( tv, pTerm->mLastEvt.BM_time ) ) + pTerm->mLastEvt.buttonstate |= M_BUTTON_MDBLCK; + TIMEVAL_ADD( pTerm->mLastEvt.BM_time, tv, + HB_GTSELF_MOUSEGETDOUBLECLICKSPEED( pTerm->pGT ) ); } if( newbuttons & M_BUTTON_RIGHT ) { - if( TIMEVAL_LESS( tv, mEvt->BR_time ) ) - mEvt->buttonstate |= M_BUTTON_RDBLCK; - TIMEVAL_ADD( mEvt->BR_time, tv, hb_mouse_GetDoubleClickSpeed() ); + if( TIMEVAL_LESS( tv, pTerm->mLastEvt.BR_time ) ) + pTerm->mLastEvt.buttonstate |= M_BUTTON_RDBLCK; + TIMEVAL_ADD( pTerm->mLastEvt.BR_time, tv, + HB_GTSELF_MOUSEGETDOUBLECLICKSPEED( pTerm->pGT ) ); } } } -static void set_tmevt( unsigned char *cMBuf, mouseEvent * mEvt ) +static void set_tmevt( PHB_GTTRM pTerm, unsigned char *cMBuf, mouseEvent * mEvt ) { int row, col; @@ -1000,55 +1013,55 @@ static void set_tmevt( unsigned char *cMBuf, mouseEvent * mEvt ) mEvt->buttonstate |= M_BUTTON_WHEELDOWN; break; } - chk_mevtdblck( mEvt ); + chk_mevtdblck( pTerm ); /* printf("\n\rmouse event: %02x, %02x, %02x\n\r", cMBuf[0], cMBuf[1], cMBuf[2]); */ return; } #ifdef HAVE_GPM_H -static int set_gpmevt( int fd, int mode, void *data ) +static int set_gpmevt( int fd, int mode, void *cargo ) { int nKey = 0; - mouseEvent *mEvt; + PHB_GTTRM pTerm; Gpm_Event gEvt; HB_SYMBOL_UNUSED( fd ); HB_SYMBOL_UNUSED( mode ); - mEvt = ( mouseEvent * ) data; + pTerm = ( PHB_GTTRM ) cargo; if( Gpm_GetEvent( &gEvt ) > 0 ) { - mEvt->row = gEvt.y; - mEvt->col = gEvt.x; + pTerm->mLastEvt.row = gEvt.y; + pTerm->mLastEvt.col = gEvt.x; if( gEvt.type & GPM_MOVE ) - mEvt->buttonstate |= M_CURSOR_MOVE; + pTerm->mLastEvt.buttonstate |= M_CURSOR_MOVE; if( gEvt.type & GPM_DOWN ) { if( gEvt.buttons & GPM_B_LEFT ) - mEvt->buttonstate |= M_BUTTON_LEFT; + pTerm->mLastEvt.buttonstate |= M_BUTTON_LEFT; if( gEvt.buttons & GPM_B_MIDDLE ) - mEvt->buttonstate |= M_BUTTON_MIDDLE; + pTerm->mLastEvt.buttonstate |= M_BUTTON_MIDDLE; if( gEvt.buttons & GPM_B_RIGHT ) - mEvt->buttonstate |= M_BUTTON_RIGHT; + pTerm->mLastEvt.buttonstate |= M_BUTTON_RIGHT; } else if( gEvt.type & GPM_UP ) { if( gEvt.buttons & GPM_B_LEFT ) - mEvt->buttonstate &= ~M_BUTTON_LEFT; + pTerm->mLastEvt.buttonstate &= ~M_BUTTON_LEFT; if( gEvt.buttons & GPM_B_MIDDLE ) - mEvt->buttonstate &= ~M_BUTTON_MIDDLE; + pTerm->mLastEvt.buttonstate &= ~M_BUTTON_MIDDLE; if( gEvt.buttons & GPM_B_RIGHT ) - mEvt->buttonstate &= ~M_BUTTON_RIGHT; + pTerm->mLastEvt.buttonstate &= ~M_BUTTON_RIGHT; } } - chk_mevtdblck( mEvt ); - nKey = getMouseKey( mEvt ); + chk_mevtdblck( pTerm ); + nKey = getMouseKey( &pTerm->mLastEvt ); return ( nKey ? SET_CLIPKEY( nKey ) : 0 ); } -static void flush_gpmevt( mouseEvent * mEvt ) +static void flush_gpmevt( PHB_GTTRM pTerm ) { if( gpm_fd >= 0 ) { @@ -1059,92 +1072,94 @@ static void flush_gpmevt( mouseEvent * mEvt ) FD_SET( gpm_fd, &rfds ); while( select( gpm_fd + 1, &rfds, NULL, NULL, &tv ) > 0 ) - set_gpmevt( gpm_fd, O_RDONLY, ( void * ) mEvt ); + set_gpmevt( gpm_fd, O_RDONLY, ( void * ) pTerm ); - while( getMouseKey( mEvt ) ) ; + while( getMouseKey( &pTerm->mLastEvt ) ) ; } return; } #endif -static void disp_mousecursor( void ) +static void disp_mousecursor( PHB_GTTRM pTerm ) { #ifdef HAVE_GPM_H - if( (s_termState.mouse_type & MOUSE_GPM) && gpm_visiblepointer ) + if( (pTerm->mouse_type & MOUSE_GPM) && gpm_visiblepointer ) { - Gpm_DrawPointer( s_termState.mLastEvt.col, s_termState.mLastEvt.row, + Gpm_DrawPointer( pTerm->mLastEvt.col, pTerm->mLastEvt.row, gpm_consolefd ); } +#else + HB_SYMBOL_UNUSED( pTerm ); #endif } -static void mouse_init( void ) +static void mouse_init( PHB_GTTRM pTerm ) { - if( s_termState.terminal_type == TERM_XTERM || - s_termState.terminal_type == TERM_LINUX ) + if( pTerm->terminal_type == TERM_XTERM || + pTerm->terminal_type == TERM_LINUX ) { - hb_gt_trm_termOut( ( BYTE * ) s_szMouseOn, strlen( s_szMouseOn ) ); - hb_gt_trm_termFlush(); - memset( ( void * ) &s_termState.mLastEvt, 0, sizeof( s_termState.mLastEvt ) ); - s_termState.mouse_type |= MOUSE_XTERM; - s_termState.mButtons = 3; + hb_gt_trm_termOut( pTerm, ( BYTE * ) s_szMouseOn, strlen( s_szMouseOn ) ); + hb_gt_trm_termFlush( pTerm ); + memset( ( void * ) &pTerm->mLastEvt, 0, sizeof( pTerm->mLastEvt ) ); + pTerm->mouse_type |= MOUSE_XTERM; + pTerm->mButtons = 3; } #ifdef HAVE_GPM_H - if( s_termState.terminal_type == TERM_LINUX ) + if( pTerm->terminal_type == TERM_LINUX ) { - s_termState.Conn.eventMask = + pTerm->Conn.eventMask = GPM_MOVE | GPM_DRAG | GPM_UP | GPM_DOWN | GPM_DOUBLE; /* give me move events but handle them anyway */ - s_termState.Conn.defaultMask = GPM_MOVE | GPM_HARD; + pTerm->Conn.defaultMask = GPM_MOVE | GPM_HARD; /* only pure mouse events, no Ctrl,Alt,Shft events */ - s_termState.Conn.minMod = s_termState.Conn.maxMod = 0; + pTerm->Conn.minMod = pTerm->Conn.maxMod = 0; gpm_zerobased = 1; gpm_visiblepointer = 0; - if( Gpm_Open( &s_termState.Conn, 0 ) >= 0 && gpm_fd >= 0 ) + if( Gpm_Open( &pTerm->Conn, 0 ) >= 0 && gpm_fd >= 0 ) { int flags; if( ( flags = fcntl( gpm_fd, F_GETFL, 0 ) ) != -1 ) fcntl( gpm_fd, F_SETFL, flags | O_NONBLOCK ); - memset( ( void * ) &s_termState.mLastEvt, 0, sizeof( s_termState.mLastEvt ) ); - flush_gpmevt( &s_termState.mLastEvt ); - add_efds( gpm_fd, O_RDONLY, set_gpmevt, ( void * ) &s_termState.mLastEvt ); - s_termState.mouse_type |= MOUSE_GPM; + memset( ( void * ) &pTerm->mLastEvt, 0, sizeof( pTerm->mLastEvt ) ); + flush_gpmevt( pTerm ); + add_efds( pTerm, gpm_fd, O_RDONLY, set_gpmevt, ( void * ) pTerm ); + pTerm->mouse_type |= MOUSE_GPM; /* * In recent GPM versions it produce unpleasure noice on the screen * so I covered it with this macro, [druzus] */ #ifdef HB_GPM_USE_XTRA - s_termState.mButtons = Gpm_GetSnapshot( NULL ); + pTerm->mButtons = Gpm_GetSnapshot( NULL ); #else - s_termState.mButtons = 3; + pTerm->mButtons = 3; #endif } } #endif } -static void mouse_exit( void ) +static void mouse_exit( PHB_GTTRM pTerm ) { - if( s_termState.mouse_type & MOUSE_XTERM ) + if( pTerm->mouse_type & MOUSE_XTERM ) { - hb_gt_trm_termOut( ( BYTE * ) s_szMouseOff, strlen( s_szMouseOff ) ); - hb_gt_trm_termFlush(); + hb_gt_trm_termOut( pTerm, ( BYTE * ) s_szMouseOff, strlen( s_szMouseOff ) ); + hb_gt_trm_termFlush( pTerm ); } #ifdef HAVE_GPM_H - if( (s_termState.mouse_type & MOUSE_GPM) && gpm_fd >= 0 ) + if( (pTerm->mouse_type & MOUSE_GPM) && gpm_fd >= 0 ) { - del_efds( gpm_fd ); + del_efds( pTerm, gpm_fd ); Gpm_Close(); } #endif } -static int get_inch( int milisec ) +static int get_inch( PHB_GTTRM pTerm, int milisec ) { - int nRet = 0, npfd = -1, nchk = s_termState.efds_no, lRead = 0; + int nRet = 0, npfd = -1, nchk = pTerm->efds_no, lRead = 0; int mode, i, n, counter; struct timeval tv, *ptv; evtFD *pefd = NULL; @@ -1166,63 +1181,63 @@ static int get_inch( int milisec ) n = -1; FD_ZERO( &rfds ); FD_ZERO( &wfds ); - for( i = 0; i < s_termState.efds_no; i++ ) + for( i = 0; i < pTerm->efds_no; i++ ) { - if( s_termState.event_fds[i]->status == EVTFDSTAT_RUN ) + if( pTerm->event_fds[i]->status == EVTFDSTAT_RUN ) { - if( s_termState.event_fds[i]->mode == O_RDWR - || s_termState.event_fds[i]->mode == O_RDONLY ) + if( pTerm->event_fds[i]->mode == O_RDWR + || pTerm->event_fds[i]->mode == O_RDONLY ) { - FD_SET( s_termState.event_fds[i]->fd, &rfds ); - if( n < s_termState.event_fds[i]->fd ) - n = s_termState.event_fds[i]->fd; + FD_SET( pTerm->event_fds[i]->fd, &rfds ); + if( n < pTerm->event_fds[i]->fd ) + n = pTerm->event_fds[i]->fd; } - if( s_termState.event_fds[i]->mode == O_RDWR - || s_termState.event_fds[i]->mode == O_WRONLY ) + if( pTerm->event_fds[i]->mode == O_RDWR + || pTerm->event_fds[i]->mode == O_WRONLY ) { - FD_SET( s_termState.event_fds[i]->fd, &wfds ); - if( n < s_termState.event_fds[i]->fd ) - n = s_termState.event_fds[i]->fd; + FD_SET( pTerm->event_fds[i]->fd, &wfds ); + if( n < pTerm->event_fds[i]->fd ) + n = pTerm->event_fds[i]->fd; } } } - counter = s_termState.key_counter; + counter = pTerm->key_counter; if( select( n + 1, &rfds, &wfds, NULL, ptv ) > 0 ) { - for( i = 0; i < s_termState.efds_no; i++ ) + for( i = 0; i < pTerm->efds_no; i++ ) { - n = ( FD_ISSET( s_termState.event_fds[i]->fd, &rfds ) ? 1 : 0 ) | - ( FD_ISSET( s_termState.event_fds[i]->fd, &wfds ) ? 2 : 0 ); + n = ( FD_ISSET( pTerm->event_fds[i]->fd, &rfds ) ? 1 : 0 ) | + ( FD_ISSET( pTerm->event_fds[i]->fd, &wfds ) ? 2 : 0 ); if( n != 0 ) { - if( s_termState.event_fds[i]->eventFunc == NULL ) + if( pTerm->event_fds[i]->eventFunc == NULL ) { lRead = 1; - if( STDIN_BUFLEN > s_termState.stdin_inbuf ) + if( STDIN_BUFLEN > pTerm->stdin_inbuf ) { unsigned char buf[STDIN_BUFLEN]; #if defined( OS_UNIX_COMPATIBLE ) - n = read( s_termState.event_fds[i]->fd, buf, - STDIN_BUFLEN - s_termState.stdin_inbuf ); + n = read( pTerm->event_fds[i]->fd, buf, + STDIN_BUFLEN - pTerm->stdin_inbuf ); #else - n = hb_fsRead( s_termState.event_fds[i]->fd, buf, - STDIN_BUFLEN - s_termState.stdin_inbuf ); + n = hb_fsRead( pTerm->event_fds[i]->fd, buf, + STDIN_BUFLEN - pTerm->stdin_inbuf ); #endif if( n == 0 ) - s_termState.event_fds[i]->status = EVTFDSTAT_STOP; + pTerm->event_fds[i]->status = EVTFDSTAT_STOP; else for( i = 0; i < n; i++ ) { - s_termState.stdin_buf[s_termState.stdin_ptr_r++] = buf[i]; - if( s_termState.stdin_ptr_r == STDIN_BUFLEN ) - s_termState.stdin_ptr_r = 0; - s_termState.stdin_inbuf++; + pTerm->stdin_buf[pTerm->stdin_ptr_r++] = buf[i]; + if( pTerm->stdin_ptr_r == STDIN_BUFLEN ) + pTerm->stdin_ptr_r = 0; + pTerm->stdin_inbuf++; } } } - else if( nRet == 0 && counter == s_termState.key_counter ) + else if( nRet == 0 && counter == pTerm->key_counter ) { if( n == 3 ) mode = O_RDWR; @@ -1230,26 +1245,26 @@ static int get_inch( int milisec ) mode = O_WRONLY; else mode = O_RDONLY; - s_termState.event_fds[i]->status = EVTFDSTAT_STOP; - n = ( s_termState.event_fds[i]->eventFunc ) ( s_termState. + pTerm->event_fds[i]->status = EVTFDSTAT_STOP; + n = ( pTerm->event_fds[i]->eventFunc ) ( pTerm-> event_fds[i]->fd, mode, - s_termState. + pTerm-> event_fds[i]-> - data ); + cargo ); if( IS_EVTFDSTAT( n ) ) { - s_termState.event_fds[i]->status = n; + pTerm->event_fds[i]->status = n; if( nchk > i ) nchk = i; } else { - s_termState.event_fds[i]->status = EVTFDSTAT_RUN; + pTerm->event_fds[i]->status = EVTFDSTAT_RUN; if( IS_CLIPKEY( n ) ) { nRet = n; - npfd = s_termState.event_fds[i]->fd; + npfd = pTerm->event_fds[i]->fd; if( nchk > i ) nchk = i; } @@ -1262,85 +1277,85 @@ static int get_inch( int milisec ) lRead = 1; } - for( i = n = nchk; i < s_termState.efds_no; i++ ) + for( i = n = nchk; i < pTerm->efds_no; i++ ) { - if( s_termState.event_fds[i]->status == EVTFDSTAT_DEL ) - hb_xfree( s_termState.event_fds[i] ); - else if( s_termState.event_fds[i]->fd == npfd ) - pefd = s_termState.event_fds[i]; + if( pTerm->event_fds[i]->status == EVTFDSTAT_DEL ) + hb_xfree( pTerm->event_fds[i] ); + else if( pTerm->event_fds[i]->fd == npfd ) + pefd = pTerm->event_fds[i]; else { if( i > n ) - s_termState.event_fds[n] = s_termState.event_fds[i]; + pTerm->event_fds[n] = pTerm->event_fds[i]; n++; } } if( pefd ) - s_termState.event_fds[n++] = pefd; - s_termState.efds_no = n; + pTerm->event_fds[n++] = pefd; + pTerm->efds_no = n; return nRet; } -static int test_bufch( int n, int delay ) +static int test_bufch( PHB_GTTRM pTerm, int n, int delay ) { int nKey = 0; - if( s_termState.stdin_inbuf == n ) - nKey = get_inch( delay ); + if( pTerm->stdin_inbuf == n ) + nKey = get_inch( pTerm, delay ); return IS_CLIPKEY( nKey ) ? nKey : - ( s_termState.stdin_inbuf > n ) ? - s_termState.stdin_buf[( s_termState.stdin_ptr_l + n ) % STDIN_BUFLEN] : -1; + ( pTerm->stdin_inbuf > n ) ? + pTerm->stdin_buf[( pTerm->stdin_ptr_l + n ) % STDIN_BUFLEN] : -1; } -static void free_bufch( int n ) +static void free_bufch( PHB_GTTRM pTerm, int n ) { - if( n > s_termState.stdin_inbuf ) - n = s_termState.stdin_inbuf; - s_termState.stdin_ptr_l = ( s_termState.stdin_ptr_l + n ) % STDIN_BUFLEN; - s_termState.stdin_inbuf -= n; + if( n > pTerm->stdin_inbuf ) + n = pTerm->stdin_inbuf; + pTerm->stdin_ptr_l = ( pTerm->stdin_ptr_l + n ) % STDIN_BUFLEN; + pTerm->stdin_inbuf -= n; } -static int wait_key( int milisec ) +static int wait_key( PHB_GTTRM pTerm, int milisec ) { int nKey, esc, n, i, ch, counter; keyTab *ptr; #if defined( OS_UNIX_COMPATIBLE ) - if( s_termState.fWinSizeChangeFlag ) + if( s_WinSizeChangeFlag ) { - s_termState.fWinSizeChangeFlag = FALSE; + s_WinSizeChangeFlag = FALSE; return K_RESIZE; } #endif - counter = ++( s_termState.key_counter ); + counter = ++( pTerm->key_counter ); restart: nKey = esc = n = i = 0; again: - if( ( nKey = getMouseKey( &s_termState.mLastEvt ) ) != 0 ) + if( ( nKey = getMouseKey( &pTerm->mLastEvt ) ) != 0 ) return nKey; - ch = test_bufch( i, s_termState.nTermMouseChars ? s_termState.esc_delay : milisec ); - if( counter != s_termState.key_counter ) + ch = test_bufch( pTerm, i, pTerm->nTermMouseChars ? pTerm->esc_delay : milisec ); + if( counter != pTerm->key_counter ) goto restart; if( ch >= 0 && ch <= 255 ) { ++i; - if( s_termState.nTermMouseChars ) + if( pTerm->nTermMouseChars ) { - s_termState.cTermMouseBuf[3 - s_termState.nTermMouseChars] = ch; - free_bufch( i ); + pTerm->cTermMouseBuf[3 - pTerm->nTermMouseChars] = ch; + free_bufch( pTerm, i ); i = 0; - if( --s_termState.nTermMouseChars == 0 ) - set_tmevt( s_termState.cTermMouseBuf, &s_termState.mLastEvt ); + if( --pTerm->nTermMouseChars == 0 ) + set_tmevt( pTerm, pTerm->cTermMouseBuf, &pTerm->mLastEvt ); goto again; } nKey = ch; - ptr = s_termState.pKeyTab; + ptr = pTerm->pKeyTab; if( i == 1 && nKey == K_ESC && esc == 0 ) esc = 1; while( ch >= 0 && ch <= 255 && ptr != NULL ) @@ -1353,23 +1368,23 @@ again: switch( nKey ) { case K_METAALT: - s_termState.key_flag |= KEY_ALTMASK; + pTerm->key_flag |= KEY_ALTMASK; break; case K_METACTRL: - s_termState.key_flag |= KEY_CTRLMASK; + pTerm->key_flag |= KEY_CTRLMASK; break; case K_NATIONAL: - s_termState.nation_mode = !s_termState.nation_mode; + pTerm->nation_mode = !pTerm->nation_mode; break; case K_MOUSETERM: - s_termState.nTermMouseChars = 3; + pTerm->nTermMouseChars = 3; break; default: n = i; } if( n != i ) { - free_bufch( i ); + free_bufch( pTerm, i ); i = n = nKey = 0; if( esc == 2 ) break; @@ -1379,17 +1394,17 @@ again: } ptr = ptr->nextCh; if( ptr ) - if( ( ch = test_bufch( i, s_termState.esc_delay ) ) != -1 ) + if( ( ch = test_bufch( pTerm, i, pTerm->esc_delay ) ) != -1 ) ++i; - if( counter != s_termState.key_counter ) + if( counter != pTerm->key_counter ) goto restart; } else ptr = ptr->otherCh; } } - if( ch == -1 && s_termState.nTermMouseChars ) - s_termState.nTermMouseChars = 0; + if( ch == -1 && pTerm->nTermMouseChars ) + pTerm->nTermMouseChars = 0; if( ch != -1 && IS_CLIPKEY( ch ) ) nKey = GET_CLIPKEY( ch ); @@ -1405,7 +1420,7 @@ again: if( esc == 2 ) { if( nKey != 0 ) - s_termState.key_flag |= KEY_ALTMASK; + pTerm->key_flag |= KEY_ALTMASK; else nKey = K_ESC; if( n == 1 && i > 1 ) @@ -1415,42 +1430,42 @@ again: n = 1; if( n > 0 ) - free_bufch( n ); + free_bufch( pTerm, n ); - if( s_termState.key_flag != 0 && nKey != 0 ) + if( pTerm->key_flag != 0 && nKey != 0 ) { - nKey |= s_termState.key_flag; - s_termState.key_flag = 0; + nKey |= pTerm->key_flag; + pTerm->key_flag = 0; } #ifndef HB_CDP_SUPPORT_OFF - if( nKey > 0 && nKey <= 255 && s_termState.fUTF8 && s_termState.cdpIn ) + if( nKey > 0 && nKey <= 255 && pTerm->fUTF8 && pTerm->cdpIn ) { USHORT uc = 0; n = i = 0; - if( hb_cdpGetFromUTF8( s_termState.cdpIn, FALSE, ( BYTE ) nKey, &n, &uc ) ) + if( hb_cdpGetFromUTF8( pTerm->cdpIn, FALSE, ( BYTE ) nKey, &n, &uc ) ) { while( n > 0 ) { - ch = test_bufch( i++, s_termState.esc_delay ); + ch = test_bufch( pTerm, i++, pTerm->esc_delay ); if( ch < 0 || ch > 255 || - !hb_cdpGetFromUTF8( s_termState.cdpIn, FALSE, ch, &n, &uc ) ) + !hb_cdpGetFromUTF8( pTerm->cdpIn, FALSE, ch, &n, &uc ) ) break; } if( n == 0 ) { - free_bufch( i ); + free_bufch( pTerm, i ); nKey = uc; } } } #endif - if( nKey > 0 && nKey <= 255 && s_termState.keyTransTbl[nKey] ) - nKey = s_termState.keyTransTbl[nKey]; + if( nKey > 0 && nKey <= 255 && pTerm->keyTransTbl[nKey] ) + nKey = pTerm->keyTransTbl[nKey]; /* - if( s_termState.nation_transtbl && s_termState.nation_mode && - nKey >= 32 && nKey < 128 && s_termState.nation_transtbl[nKey] ) - nKey = s_termState.nation_transtbl[nKey]; + if( pTerm->nation_transtbl && pTerm->nation_mode && + nKey >= 32 && nKey < 128 && pTerm->nation_transtbl[nKey] ) + nKey = pTerm->nation_transtbl[nKey]; */ if( nKey ) nKey = getClipKey( nKey ); @@ -1464,46 +1479,45 @@ again: /* * LINUX terminal operations */ -static void hb_gt_trm_LinuxSetTermMode( int iAM ) +static void hb_gt_trm_LinuxSetTermMode( PHB_GTTRM pTerm, int iAM ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_LinuxSetTermMode(%d)", iAM)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_LinuxSetTermMode(%p,%d)", pTerm, iAM)); - if( iAM != s_termState.iAM ) + if( iAM != pTerm->iAM ) { if( iAM == 0 ) - { - hb_gt_trm_termOut( ( BYTE * ) "\x1B[m", 3 ); - } - hb_gt_trm_termOut( ( BYTE * ) ( iAM ? "\x1B[?7h" : "\x1B[?7l" ), 5 ); - s_termState.iAM = iAM; + hb_gt_trm_termOut( pTerm, ( BYTE * ) "\x1B[m", 3 ); + + hb_gt_trm_termOut( pTerm, ( BYTE * ) ( iAM ? "\x1B[?7h" : "\x1B[?7l" ), 5 ); + pTerm->iAM = iAM; } } -static void hb_gt_trm_LinuxTone( double dFrequency, double dDuration ) +static void hb_gt_trm_LinuxTone( PHB_GTTRM pTerm, double dFrequency, double dDuration ) { char escseq[64]; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_LinuxTone(%lf, %lf)", dFrequency, dDuration)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_LinuxTone(%p,%lf,%lf)", pTerm, dFrequency, dDuration)); - if( s_termState.iACSC ) + if( pTerm->iACSC ) { - hb_gt_trm_termOut( ( BYTE * ) "\033[10m", 5 ); - s_termState.iACSC = 0; + hb_gt_trm_termOut( pTerm, ( BYTE * ) "\033[10m", 5 ); + pTerm->iACSC = 0; } snprintf( escseq, sizeof( escseq ), "\033[10;%d]\033[11;%d]\007", ( int ) dFrequency, ( int ) ( dDuration * 1000.0 / 18.2 ) ); - hb_gt_trm_termOut( ( BYTE * ) escseq, strlen( escseq ) ); - hb_gt_trm_termFlush(); + hb_gt_trm_termOut( pTerm, ( BYTE * ) escseq, strlen( escseq ) ); + hb_gt_trm_termFlush( pTerm ); /* convert Clipper (DOS) timer tick units to seconds ( x / 18.2 ) */ hb_idleSleep( dDuration / 18.2 ); } -static void hb_gt_trm_LinuxSetCursorStyle( int iStyle ) +static void hb_gt_trm_LinuxSetCursorStyle( PHB_GTTRM pTerm, int iStyle ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_LinuxSetCursorStyle(%d)", iStyle)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_LinuxSetCursorStyle(%p,%d)", pTerm, iStyle)); - if( s_termState.iCursorStyle != iStyle ) + if( pTerm->iCursorStyle != iStyle ) { int lcurs = -1; @@ -1534,8 +1548,8 @@ static void hb_gt_trm_LinuxSetCursorStyle( int iStyle ) char escseq[64]; snprintf( escseq, sizeof( escseq ), "\033[?25%c\033[?%hdc", iStyle == SC_NONE ? 'l' : 'h', lcurs ); - hb_gt_trm_termOut( ( BYTE * ) escseq, strlen( escseq ) ); - s_termState.iCursorStyle = iStyle; + hb_gt_trm_termOut( pTerm, ( BYTE * ) escseq, strlen( escseq ) ); + pTerm->iCursorStyle = iStyle; } } } @@ -1544,38 +1558,38 @@ static void hb_gt_trm_LinuxSetCursorStyle( int iStyle ) /* * XTERM terminal operations */ -static BOOL hb_gt_trm_XtermSetMode( int * piRows, int * piCols ) +static BOOL hb_gt_trm_XtermSetMode( PHB_GTTRM pTerm, int * piRows, int * piCols ) { int iHeight, iWidth; char escseq[64]; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_XtermSetMode(%d, %d)", *piRows, *piCols)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_XtermSetMode(%p,%d,%d)", pTerm, *piRows, *piCols)); - hb_gt_GetSize( &iHeight, &iWidth ); + HB_GTSELF_GETSIZE( pTerm->pGT, &iHeight, &iWidth ); snprintf( escseq, sizeof( escseq ), "\033[8;%d;%dt", *piRows, *piCols ); - hb_gt_trm_termOut( ( BYTE * ) escseq, strlen( escseq ) ); - hb_gt_trm_termFlush(); + hb_gt_trm_termOut( pTerm, ( BYTE * ) escseq, strlen( escseq ) ); + hb_gt_trm_termFlush( pTerm ); #if defined( OS_UNIX_COMPATIBLE ) /* dirty hack - wait for SIGWINCH */ if( *piRows != iHeight || *piCols != iWidth ) sleep( 3 ); - if( s_termState.fWinSizeChangeFlag ) - s_termState.fWinSizeChangeFlag = FALSE; + if( s_WinSizeChangeFlag ) + s_WinSizeChangeFlag = FALSE; #endif - hb_gt_trm_getSize( piRows, piCols ); + hb_gt_trm_getSize( pTerm, piRows, piCols ); return TRUE; } -static void hb_gt_trm_XtermSetAttributes( int iAttr ) +static void hb_gt_trm_XtermSetAttributes( PHB_GTTRM pTerm, int iAttr ) { static const int s_AnsiColors[] = { 0, 4, 2, 6, 1, 5, 3, 7 }; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_XtermSetAttributes(%d)", iAttr)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_XtermSetAttributes(%p,%d)", pTerm, iAttr)); - if( s_termState.iCurrentSGR != iAttr ) + if( pTerm->iCurrentSGR != iAttr ) { int i, acsc, bg, fg, bold, blink; BYTE buff[32]; @@ -1584,13 +1598,13 @@ static void hb_gt_trm_XtermSetAttributes( int iAttr ) buff[ 0 ] = 0x1b; buff[ 1 ] = '['; - acsc = ( iAttr & HB_GTTRM_ATTR_ACSC ) && !s_termState.fUTF8 ? 1 : 0; + acsc = ( iAttr & HB_GTTRM_ATTR_ACSC ) && !pTerm->fUTF8 ? 1 : 0; bg = s_AnsiColors[ ( iAttr >> 4 ) & 0x07 ]; fg = s_AnsiColors[ iAttr & 0x07 ]; bold = iAttr & 0x08 ? 1 : 0; blink = iAttr & 0x80 ? 1 : 0; - if( s_termState.iCurrentSGR == -1 ) + if( pTerm->iCurrentSGR == -1 ) { buff[ i++ ] = 'm'; buff[ i++ ] = 0x1b; @@ -1616,15 +1630,15 @@ static void hb_gt_trm_XtermSetAttributes( int iAttr ) buff[ i++ ] = '4'; buff[ i++ ] = '0' + bg; buff[ i++ ] = 'm'; - s_termState.iACSC = acsc; - s_termState.iBold = bold; - s_termState.iBlink = blink; - s_termState.iFgColor = fg; - s_termState.iBgColor = bg; + pTerm->iACSC = acsc; + pTerm->iBold = bold; + pTerm->iBlink = blink; + pTerm->iFgColor = fg; + pTerm->iBgColor = bg; } else { - if( s_termState.iBold != bold ) + if( pTerm->iBold != bold ) { if( bold ) buff[ i++ ] = '1'; @@ -1634,45 +1648,45 @@ static void hb_gt_trm_XtermSetAttributes( int iAttr ) buff[ i++ ] = '2'; } buff[ i++ ] = ';'; - s_termState.iBold = bold; + pTerm->iBold = bold; } - if( s_termState.iBlink != blink ) + if( pTerm->iBlink != blink ) { if( !blink ) buff[ i++ ] = '2'; buff[ i++ ] = '5'; buff[ i++ ] = ';'; - s_termState.iBlink = blink; + pTerm->iBlink = blink; } - if( s_termState.iFgColor != fg ) + if( pTerm->iFgColor != fg ) { buff[ i++ ] = '3'; buff[ i++ ] = '0' + fg; buff[ i++ ] = ';'; - s_termState.iFgColor = fg; + pTerm->iFgColor = fg; } - if( s_termState.iBgColor != bg ) + if( pTerm->iBgColor != bg ) { buff[ i++ ] = '4'; buff[ i++ ] = '0' + bg; buff[ i++ ] = ';'; - s_termState.iBgColor = bg; + pTerm->iBgColor = bg; } buff[ i - 1 ] = 'm'; - if( s_termState.iACSC != acsc ) + if( pTerm->iACSC != acsc ) { if( i <= 2 ) i = 0; buff[ i++ ] = 0x1b; buff[ i++ ] = '('; buff[ i++ ] = acsc ? '0' : 'B'; - s_termState.iACSC = acsc; + pTerm->iACSC = acsc; } } - s_termState.iCurrentSGR = iAttr; + pTerm->iCurrentSGR = iAttr; if( i > 2 ) { - hb_gt_trm_termOut( buff, i ); + hb_gt_trm_termOut( pTerm, buff, i ); } } } @@ -1682,42 +1696,42 @@ static void hb_gt_trm_XtermSetAttributes( int iAttr ) /* * ANSI terminal operations */ -static void hb_gt_trm_AnsiSetTermMode( int iAM ) +static void hb_gt_trm_AnsiSetTermMode( PHB_GTTRM pTerm, int iAM ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiSetTermMode(%d)", iAM)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiSetTermMode(%p,%d)", pTerm, iAM)); - if( iAM != s_termState.iAM ) + if( iAM != pTerm->iAM ) { if( iAM == 0 ) { - hb_gt_trm_termOut( ( BYTE * ) "\x1B[0m", 4 ); + hb_gt_trm_termOut( pTerm, ( BYTE * ) "\x1B[0m", 4 ); } /* * disabled until I'll find good PC-ANSI terminal documentation with * detail Auto Margin and Auto Line Wrapping description, [druzus] */ #if 0 - hb_gt_trm_termOut( ( BYTE * ) ( iAM ? "\x1B[?7h" : "\x1B[?7l" ), 5 ); + hb_gt_trm_termOut( pTerm, ( BYTE * ) ( iAM ? "\x1B[?7h" : "\x1B[?7l" ), 5 ); #endif - s_termState.iAM = iAM; + pTerm->iAM = iAM; } } -static BOOL hb_gt_trm_AnsiGetCursorPos( int * iRow, int * iCol ) +static BOOL hb_gt_trm_AnsiGetCursorPos( PHB_GTTRM pTerm, int * iRow, int * iCol ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiGetCursorPos(%p, %p)", iRow, iCol)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiGetCursorPos(%p,%p,%p)", pTerm, iRow, iCol)); - if( s_termState.fPosAnswer ) + if( pTerm->fPosAnswer ) { char rdbuf[ 64 ]; int i, n, y, x; - hb_gt_trm_termOut( ( BYTE * ) "\x1B[6n", 4 ); - hb_gt_trm_termFlush(); + hb_gt_trm_termOut( pTerm, ( BYTE * ) "\x1B[6n", 4 ); + hb_gt_trm_termFlush( pTerm ); *iRow = *iCol = -1; n = 0; - s_termState.fPosAnswer = FALSE; + pTerm->fPosAnswer = FALSE; #ifdef OS_UNIX_COMPATIBLE { @@ -1725,13 +1739,13 @@ static BOOL hb_gt_trm_AnsiGetCursorPos( int * iRow, int * iCol ) fd_set rdfds; FD_ZERO( &rdfds ); - FD_SET( s_termState.hFilenoStdin, &rdfds ); + FD_SET( pTerm->hFilenoStdin, &rdfds ); tv.tv_sec = 2; tv.tv_usec = 0; - while( select( s_termState.hFilenoStdin + 1, &rdfds, NULL, NULL, &tv ) > 0 ) + while( select( pTerm->hFilenoStdin + 1, &rdfds, NULL, NULL, &tv ) > 0 ) { - i = read( s_termState.hFilenoStdin, rdbuf + n, sizeof( rdbuf ) - 1 - n ); + i = read( pTerm->hFilenoStdin, rdbuf + n, sizeof( rdbuf ) - 1 - n ); if( i <= 0 ) break; if( n == 0 ) @@ -1745,7 +1759,7 @@ static BOOL hb_gt_trm_AnsiGetCursorPos( int * iRow, int * iCol ) rdbuf[ n ] = '\0'; if( sscanf( rdbuf, "\033[%d;%dR", &y, &x ) == 2 ) { - s_termState.fPosAnswer = TRUE; + pTerm->fPosAnswer = TRUE; break; } else if( n == sizeof( rdbuf ) ) @@ -1768,7 +1782,7 @@ static BOOL hb_gt_trm_AnsiGetCursorPos( int * iRow, int * iCol ) rdbuf[ n ] = '\0'; if( sscanf( rdbuf, "\033[%d;%dR", &y, &x ) == 2 ) { - s_termState.fPosAnswer = TRUE; + pTerm->fPosAnswer = TRUE; break; } n = 0; @@ -1779,7 +1793,7 @@ static BOOL hb_gt_trm_AnsiGetCursorPos( int * iRow, int * iCol ) while( d <= dTime + 2.0 && d > dTime ); } #endif - if( s_termState.fPosAnswer ) + if( pTerm->fPosAnswer ) { *iRow = y - 1; *iCol = x - 1; @@ -1789,42 +1803,42 @@ static BOOL hb_gt_trm_AnsiGetCursorPos( int * iRow, int * iCol ) *iRow = *iCol = -1; } } - return s_termState.fPosAnswer; + return pTerm->fPosAnswer; } -static void hb_gt_trm_AnsiSetCursorPos( int iRow, int iCol ) +static void hb_gt_trm_AnsiSetCursorPos( PHB_GTTRM pTerm, int iRow, int iCol ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiSetCursorPos(%d, %d)", iRow, iCol)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiSetCursorPos(%p,%d,%d)", pTerm, iRow, iCol)); - if( s_termState.iRow != iRow || s_termState.iCol != iCol ) + if( pTerm->iRow != iRow || pTerm->iCol != iCol ) { char buff[16]; snprintf( buff, sizeof( buff ), "\x1B[%d;%dH", iRow + 1, iCol + 1 ); - hb_gt_trm_termOut( ( BYTE * ) buff, strlen( buff ) ); - s_termState.iRow = iRow; - s_termState.iCol = iCol; + hb_gt_trm_termOut( pTerm, ( BYTE * ) buff, strlen( buff ) ); + pTerm->iRow = iRow; + pTerm->iCol = iCol; } } -static void hb_gt_trm_AnsiSetCursorStyle( int iStyle ) +static void hb_gt_trm_AnsiSetCursorStyle( PHB_GTTRM pTerm, int iStyle ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiSetCursorStyle(%d)", iStyle)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiSetCursorStyle(%p,%d)", pTerm, iStyle)); - if( s_termState.iCursorStyle != iStyle ) + if( pTerm->iCursorStyle != iStyle ) { - hb_gt_trm_termOut( ( BYTE * ) ( iStyle == SC_NONE ? "\x1B[?25l" : - "\x1B[?25h" ), 6 ); - s_termState.iCursorStyle = iStyle; + hb_gt_trm_termOut( pTerm, ( BYTE * ) ( iStyle == SC_NONE ? + "\x1B[?25l" : "\x1B[?25h" ), 6 ); + pTerm->iCursorStyle = iStyle; } } -static void hb_gt_trm_AnsiSetAttributes( int iAttr ) +static void hb_gt_trm_AnsiSetAttributes( PHB_GTTRM pTerm, int iAttr ) { static const int s_AnsiColors[] = { 0, 4, 2, 6, 1, 5, 3, 7 }; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiSetAttributes(%d)", iAttr)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiSetAttributes(%p,%d)", pTerm, iAttr)); - if( s_termState.iCurrentSGR != iAttr ) + if( pTerm->iCurrentSGR != iAttr ) { int i, acsc, bg, fg, bold, blink; BYTE buff[32]; @@ -1839,7 +1853,7 @@ static void hb_gt_trm_AnsiSetAttributes( int iAttr ) bold = iAttr & 0x08 ? 1 : 0; blink = iAttr & 0x80 ? 1 : 0; - if( s_termState.iCurrentSGR == -1 ) + if( pTerm->iCurrentSGR == -1 ) { buff[ i++ ] = '0'; buff[ i++ ] = ';'; @@ -1862,22 +1876,22 @@ static void hb_gt_trm_AnsiSetAttributes( int iAttr ) buff[ i++ ] = '4'; buff[ i++ ] = '0' + bg; buff[ i++ ] = 'm'; - s_termState.iACSC = acsc; - s_termState.iBold = bold; - s_termState.iBlink = blink; - s_termState.iFgColor = fg; - s_termState.iBgColor = bg; + pTerm->iACSC = acsc; + pTerm->iBold = bold; + pTerm->iBlink = blink; + pTerm->iFgColor = fg; + pTerm->iBgColor = bg; } else { - if( s_termState.iACSC != acsc ) + if( pTerm->iACSC != acsc ) { buff[ i++ ] = '1'; buff[ i++ ] = acsc ? '1' : '0'; buff[ i++ ] = ';'; - s_termState.iACSC = acsc; + pTerm->iACSC = acsc; } - if( s_termState.iBold != bold ) + if( pTerm->iBold != bold ) { if( bold ) buff[ i++ ] = '1'; @@ -1887,47 +1901,47 @@ static void hb_gt_trm_AnsiSetAttributes( int iAttr ) buff[ i++ ] = '2'; } buff[ i++ ] = ';'; - s_termState.iBold = bold; + pTerm->iBold = bold; } - if( s_termState.iBlink != blink ) + if( pTerm->iBlink != blink ) { if( !blink ) buff[ i++ ] = '2'; buff[ i++ ] = '5'; buff[ i++ ] = ';'; - s_termState.iBlink = blink; + pTerm->iBlink = blink; } - if( s_termState.iFgColor != fg ) + if( pTerm->iFgColor != fg ) { buff[ i++ ] = '3'; buff[ i++ ] = '0' + fg; buff[ i++ ] = ';'; - s_termState.iFgColor = fg; + pTerm->iFgColor = fg; } - if( s_termState.iBgColor != bg ) + if( pTerm->iBgColor != bg ) { buff[ i++ ] = '4'; buff[ i++ ] = '0' + bg; buff[ i++ ] = ';'; - s_termState.iBgColor = bg; + pTerm->iBgColor = bg; } buff[ i - 1 ] = 'm'; } - s_termState.iCurrentSGR = iAttr; + pTerm->iCurrentSGR = iAttr; if( i > 2 ) { - hb_gt_trm_termOut( buff, i ); + hb_gt_trm_termOut( pTerm, buff, i ); } } } -static int hb_gt_trm_AnsiGetAcsc( unsigned char c ) +static int hb_gt_trm_AnsiGetAcsc( PHB_GTTRM pTerm, unsigned char c ) { unsigned char *ptr; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiGetAcsc(%d)", c)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiGetAcsc(%p,%d)", pTerm, c)); - for( ptr = ( unsigned char * ) s_termState.szAcsc; *ptr && *( ptr + 1 ); ptr += 2 ) + for( ptr = ( unsigned char * ) pTerm->szAcsc; *ptr && *( ptr + 1 ); ptr += 2 ) { if( *ptr == c ) return *( ptr + 1 ) | HB_GTTRM_ATTR_ACSC; @@ -1947,35 +1961,36 @@ static int hb_gt_trm_AnsiGetAcsc( unsigned char c ) return '#' | HB_GTTRM_ATTR_STD; case '0': case 'h': - return hb_gt_trm_AnsiGetAcsc( 'a' ); + return hb_gt_trm_AnsiGetAcsc( pTerm, 'a' ); } return c | HB_GTTRM_ATTR_ALT; } -static BOOL hb_gt_trm_AnsiSetMode( int * piRow, int * piCol ) +static BOOL hb_gt_trm_AnsiSetMode( PHB_GTTRM pTerm, int * piRow, int * piCol ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiSetMode(%d, %d)", *piRow, *piCol)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiSetMode(%p,%d,%d)", pTerm, *piRow, *piCol)); + HB_SYMBOL_UNUSED( pTerm ); HB_SYMBOL_UNUSED( piRow ); HB_SYMBOL_UNUSED( piCol ); return FALSE; } -static void hb_gt_trm_AnsiBell( void ) +static void hb_gt_trm_AnsiBell( PHB_GTTRM pTerm ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_gt_trm_AnsiBell()" ) ); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiBell(%p)", pTerm) ); - hb_gt_trm_termOut( s_szBell, 1 ); - hb_gt_trm_termFlush(); + hb_gt_trm_termOut( pTerm, s_szBell, 1 ); + hb_gt_trm_termFlush( pTerm ); } -static void hb_gt_trm_AnsiTone( double dFrequency, double dDuration ) +static void hb_gt_trm_AnsiTone( PHB_GTTRM pTerm, double dFrequency, double dDuration ) { double dCurrentSeconds; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiTone(%lf, %lf)", dFrequency, dDuration)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiTone(%p,%lf,%lf)", pTerm, dFrequency, dDuration)); /* Output an ASCII BEL character to cause a sound */ /* but throttle to max once per second, in case of sound */ @@ -1983,11 +1998,11 @@ static void hb_gt_trm_AnsiTone( double dFrequency, double dDuration ) /* succession leading to BEL hell on the terminal */ dCurrentSeconds = hb_dateSeconds(); - if( dCurrentSeconds < s_termState.dToneSeconds || - dCurrentSeconds - s_termState.dToneSeconds > 0.5 ) + if( dCurrentSeconds < pTerm->dToneSeconds || + dCurrentSeconds - pTerm->dToneSeconds > 0.5 ) { - hb_gt_trm_AnsiBell(); - s_termState.dToneSeconds = dCurrentSeconds; + hb_gt_trm_AnsiBell( pTerm ); + pTerm->dToneSeconds = dCurrentSeconds; } HB_SYMBOL_UNUSED( dFrequency ); @@ -1996,22 +2011,22 @@ static void hb_gt_trm_AnsiTone( double dFrequency, double dDuration ) hb_idleSleep( dDuration / 18.2 ); } -static void hb_gt_trm_AnsiInit( void ) +static void hb_gt_trm_AnsiInit( PHB_GTTRM pTerm ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiInit()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiInit(%p)", pTerm)); - s_termState.iCurrentSGR = s_termState.iRow = s_termState.iCol = - s_termState.iCursorStyle = s_termState.iACSC = s_termState.iAM = -1; + pTerm->iCurrentSGR = pTerm->iRow = pTerm->iCol = + pTerm->iCursorStyle = pTerm->iACSC = pTerm->iAM = -1; } -static void hb_gt_trm_AnsiExit( void ) +static void hb_gt_trm_AnsiExit( PHB_GTTRM pTerm ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiExit()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_AnsiExit(%p)", pTerm)); /* set default color */ - s_termState.SetAttributes( 0x07 & s_termState.iAttrMask ); - s_termState.SetCursorStyle( SC_NORMAL ); - s_termState.SetTermMode( 1 ); + pTerm->SetAttributes( pTerm, 0x07 & pTerm->iAttrMask ); + pTerm->SetCursorStyle( pTerm, SC_NORMAL ); + pTerm->SetTermMode( pTerm, 1 ); } /* ************************************************************************* */ @@ -2019,20 +2034,20 @@ static void hb_gt_trm_AnsiExit( void ) /* * common functions */ -static BOOL hb_trm_isUTF8( void ) +static BOOL hb_trm_isUTF8( PHB_GTTRM pTerm ) { char * szLang; - if( s_termState.fPosAnswer ) + if( pTerm->fPosAnswer ) { int iRow = 0, iCol = 0; BOOL fSize; - hb_gt_trm_termOut( ( BYTE * ) "\r\303\255", 3 ); - hb_gt_trm_termFlush(); - fSize = s_termState.GetCursorPos( &iRow, &iCol ); - hb_gt_trm_termOut( ( BYTE * ) "\r \r", 4 ); - hb_gt_trm_termFlush(); - s_termState.iCol = 0; + hb_gt_trm_termOut( pTerm, ( BYTE * ) "\r\303\255", 3 ); + hb_gt_trm_termFlush( pTerm ); + fSize = pTerm->GetCursorPos( pTerm, &iRow, &iCol ); + hb_gt_trm_termOut( pTerm, ( BYTE * ) "\r \r", 4 ); + hb_gt_trm_termFlush( pTerm ); + pTerm->iCol = 0; if( fSize ) return iCol == 1; } @@ -2040,76 +2055,76 @@ static BOOL hb_trm_isUTF8( void ) return szLang && strstr( szLang, "UTF-8" ) != NULL; } -static void hb_gt_trm_PutStr( int iRow, int iCol, int iAttr, BYTE *pStr, int iLen ) +static void hb_gt_trm_PutStr( PHB_GTTRM pTerm, int iRow, int iCol, int iAttr, BYTE *pStr, int iLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_PutStr(%d,%d,%d,%p,%d)", iRow, iCol, iAttr, pStr, iLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_PutStr(%p,%d,%d,%d,%p,%d)", pTerm, iRow, iCol, iAttr, pStr, iLen)); - if( s_termState.iOutBufSize ) + if( pTerm->iOutBufSize ) { - s_termState.SetCursorPos( iRow, iCol ); - s_termState.SetAttributes( iAttr & s_termState.iAttrMask ); - hb_gt_trm_termOutTrans( pStr, iLen, iAttr ); + pTerm->SetCursorPos( pTerm, iRow, iCol ); + pTerm->SetAttributes( pTerm, iAttr & pTerm->iAttrMask ); + hb_gt_trm_termOutTrans( pTerm, pStr, iLen, iAttr ); } - s_termState.iCol += iLen; + pTerm->iCol += iLen; } -static void hb_gt_trm_SetKeyTrans( char * pSrcChars, char * pDstChars ) +static void hb_gt_trm_SetKeyTrans( PHB_GTTRM pTerm, char * pSrcChars, char * pDstChars ) { int i; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_SetKeyTrans(%s, %s)", pSrcChars, pDstChars)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_SetKeyTrans(%p,%s,%s)", pTerm, pSrcChars, pDstChars)); for( i = 0; i < 256; ++i ) - s_termState.keyTransTbl[ i ] = ( BYTE ) i; + pTerm->keyTransTbl[ i ] = ( BYTE ) i; if( pSrcChars && pDstChars ) { BYTE c; for( i = 0; i < 256 && ( c = ( BYTE ) pSrcChars[ i ] ) != 0; ++i ) - s_termState.keyTransTbl[ c ] = ( BYTE ) pDstChars[ i ]; + pTerm->keyTransTbl[ c ] = ( BYTE ) pDstChars[ i ]; } } -static void hb_gt_trm_SetDispTrans( char * src, char * dst, int box ) +static void hb_gt_trm_SetDispTrans( PHB_GTTRM pTerm, char * src, char * dst, int box ) { unsigned char c, d; int i, ch, mode; - memset( s_termState.chrattr, 0, sizeof( s_termState.chrattr ) ); - memset( s_termState.boxattr, 0, sizeof( s_termState.boxattr ) ); + memset( pTerm->chrattr, 0, sizeof( pTerm->chrattr ) ); + memset( pTerm->boxattr, 0, sizeof( pTerm->boxattr ) ); for( i = 0; i < 256; i++ ) { - ch = s_termState.charmap[i] & 0xffff; - mode = !s_termState.fUTF8 ? ( s_termState.charmap[i] >> 16 ) & 0xff : 0; + ch = pTerm->charmap[i] & 0xffff; + mode = !pTerm->fUTF8 ? ( pTerm->charmap[i] >> 16 ) & 0xff : 0; switch( mode ) { case 1: - s_termState.chrattr[i] = s_termState.boxattr[i] = HB_GTTRM_ATTR_STD; + pTerm->chrattr[i] = pTerm->boxattr[i] = HB_GTTRM_ATTR_STD; break; case 2: - s_termState.chrattr[i] = s_termState.boxattr[i] = HB_GTTRM_ATTR_ALT; + pTerm->chrattr[i] = pTerm->boxattr[i] = HB_GTTRM_ATTR_ALT; break; case 3: - s_termState.chrattr[i] = s_termState.boxattr[i] = HB_GTTRM_ATTR_PROT; + pTerm->chrattr[i] = pTerm->boxattr[i] = HB_GTTRM_ATTR_PROT; break; case 4: - s_termState.chrattr[i] = s_termState.boxattr[i] = HB_GTTRM_ATTR_ALT | HB_GTTRM_ATTR_PROT; + pTerm->chrattr[i] = pTerm->boxattr[i] = HB_GTTRM_ATTR_ALT | HB_GTTRM_ATTR_PROT; break; case 5: - ch = s_termState.GetAcsc( ch & 0xff ); - s_termState.chrattr[i] = s_termState.boxattr[i] = ch & ~HB_GTTRM_ATTR_CHAR; + ch = pTerm->GetAcsc( pTerm, ch & 0xff ); + pTerm->chrattr[i] = pTerm->boxattr[i] = ch & ~HB_GTTRM_ATTR_CHAR; break; case 0: default: - s_termState.chrattr[i] = HB_GTTRM_ATTR_STD; - s_termState.boxattr[i] = HB_GTTRM_ATTR_ALT; + pTerm->chrattr[i] = HB_GTTRM_ATTR_STD; + pTerm->boxattr[i] = HB_GTTRM_ATTR_ALT; break; } - s_termState.chrattr[i] |= ch; - s_termState.boxattr[i] |= ch; + pTerm->chrattr[i] |= ch; + pTerm->boxattr[i] |= ch; } if( src && dst ) @@ -2117,14 +2132,14 @@ static void hb_gt_trm_SetDispTrans( char * src, char * dst, int box ) for( i = 0; i < 256 && ( c = ( unsigned char ) src[i] ) != 0; i++ ) { d = ( unsigned char ) dst[i]; - s_termState.chrattr[c] = d | HB_GTTRM_ATTR_STD; + pTerm->chrattr[c] = d | HB_GTTRM_ATTR_STD; if( box ) - s_termState.boxattr[c] = d | HB_GTTRM_ATTR_STD; + pTerm->boxattr[c] = d | HB_GTTRM_ATTR_STD; } } } -static int addKeyMap( int nKey, const char *cdesc ) +static int addKeyMap( PHB_GTTRM pTerm, int nKey, const char *cdesc ) { int ret = K_UNDEF, i = 0, c; keyTab **ptr; @@ -2133,7 +2148,7 @@ static int addKeyMap( int nKey, const char *cdesc ) return ret; c = ( unsigned char ) cdesc[i++]; - ptr = &s_termState.pKeyTab; + ptr = &pTerm->pKeyTab; while( c ) { @@ -2162,13 +2177,13 @@ static int addKeyMap( int nKey, const char *cdesc ) return ret; } -static int removeKeyMap( const char *cdesc ) +static int removeKeyMap( PHB_GTTRM pTerm, const char *cdesc ) { int ret = K_UNDEF, i = 0, c; keyTab **ptr; c = ( unsigned char ) cdesc[i++]; - ptr = &s_termState.pKeyTab; + ptr = &pTerm->pKeyTab; while( c && *ptr != NULL ) { @@ -2194,27 +2209,27 @@ static int removeKeyMap( const char *cdesc ) return ret; } -static void removeAllKeyMap( keyTab **ptr ) +static void removeAllKeyMap( PHB_GTTRM pTerm, keyTab **ptr ) { if( ( *ptr )->nextCh != NULL ) - removeAllKeyMap( &( ( *ptr )->nextCh ) ); + removeAllKeyMap( pTerm, &( ( *ptr )->nextCh ) ); if( ( *ptr )->otherCh != NULL ) - removeAllKeyMap( &( ( *ptr )->otherCh ) ); + removeAllKeyMap( pTerm, &( ( *ptr )->otherCh ) ); hb_xfree( *ptr ); *ptr = NULL; } -static void addKeyTab( const keySeq * keys ) +static void addKeyTab( PHB_GTTRM pTerm, const keySeq * keys ) { while( keys->key ) { - addKeyMap( keys->key, keys->seq ); + addKeyMap( pTerm, keys->key, keys->seq ); ++keys; } } -static void init_keys( void ) +static void init_keys( PHB_GTTRM pTerm ) { static const keySeq stdKeySeq[] = { @@ -2590,28 +2605,28 @@ static void init_keys( void ) { 0, NULL } }; - addKeyTab( stdKeySeq ); - if( s_termState.terminal_type == TERM_XTERM ) + addKeyTab( pTerm, stdKeySeq ); + if( pTerm->terminal_type == TERM_XTERM ) { - addKeyTab( xtermKeySeq ); - addKeyTab( xtermFnKeySeq ); - addKeyTab( stdFnKeySeq ); - addKeyTab( stdCursorKeySeq ); - addKeyTab( xtermModKeySeq ); - addKeyTab( puttyKeySeq ); + addKeyTab( pTerm, xtermKeySeq ); + addKeyTab( pTerm, xtermFnKeySeq ); + addKeyTab( pTerm, stdFnKeySeq ); + addKeyTab( pTerm, stdCursorKeySeq ); + addKeyTab( pTerm, xtermModKeySeq ); + addKeyTab( pTerm, puttyKeySeq ); } - else if( s_termState.terminal_type == TERM_LINUX ) + else if( pTerm->terminal_type == TERM_LINUX ) { - addKeyTab( linuxKeySeq ); - addKeyTab( stdFnKeySeq ); - addKeyTab( stdCursorKeySeq ); - addKeyTab( xtermFnKeySeq ); - addKeyTab( xtermModKeySeq ); - addKeyTab( puttyKeySeq ); + addKeyTab( pTerm, linuxKeySeq ); + addKeyTab( pTerm, stdFnKeySeq ); + addKeyTab( pTerm, stdCursorKeySeq ); + addKeyTab( pTerm, xtermFnKeySeq ); + addKeyTab( pTerm, xtermModKeySeq ); + addKeyTab( pTerm, puttyKeySeq ); } - else if( s_termState.terminal_type == TERM_ANSI ) + else if( pTerm->terminal_type == TERM_ANSI ) { - addKeyTab( ansiKeySeq ); + addKeyTab( pTerm, ansiKeySeq ); } #if 0 @@ -2632,88 +2647,88 @@ static void init_keys( void ) #if 0 /* (curses) termcap/terminfo sequences */ /* FlagShip extension */ - addKeyMap( EXKEY_HOME | KEY_CTRLMASK, tiGetS( "ked" ) ); - addKeyMap( EXKEY_END | KEY_CTRLMASK, tiGetS( "kel" ) ); - addKeyMap( EXKEY_PGUP | KEY_CTRLMASK, tiGetS( "kri" ) ); - addKeyMap( EXKEY_PGDN | KEY_CTRLMASK, tiGetS( "kind" ) ); - addKeyMap( EXKEY_RIGHT | KEY_CTRLMASK, tiGetS( "kctab" ) ); - addKeyMap( EXKEY_LEFT | KEY_CTRLMASK, tiGetS( "khts" ) ); + addKeyMap( pTerm, EXKEY_HOME | KEY_CTRLMASK, tiGetS( "ked" ) ); + addKeyMap( pTerm, EXKEY_END | KEY_CTRLMASK, tiGetS( "kel" ) ); + addKeyMap( pTerm, EXKEY_PGUP | KEY_CTRLMASK, tiGetS( "kri" ) ); + addKeyMap( pTerm, EXKEY_PGDN | KEY_CTRLMASK, tiGetS( "kind" ) ); + addKeyMap( pTerm, EXKEY_RIGHT | KEY_CTRLMASK, tiGetS( "kctab" ) ); + addKeyMap( pTerm, EXKEY_LEFT | KEY_CTRLMASK, tiGetS( "khts" ) ); /* some xterms extension */ - addKeyMap( EXKEY_HOME, tiGetS( "kfnd" ) ); - addKeyMap( EXKEY_END, tiGetS( "kslt" ) ); + addKeyMap( pTerm, EXKEY_HOME, tiGetS( "kfnd" ) ); + addKeyMap( pTerm, EXKEY_END, tiGetS( "kslt" ) ); /* keypad */ - addKeyMap( EXKEY_CENTER, tiGetS( "kb2" ) ); - addKeyMap( EXKEY_HOME, tiGetS( "ka1" ) ); - addKeyMap( EXKEY_END, tiGetS( "kc1" ) ); - addKeyMap( EXKEY_PGUP, tiGetS( "ka3" ) ); - addKeyMap( EXKEY_PGDN, tiGetS( "kc3" ) ); + addKeyMap( pTerm, EXKEY_CENTER, tiGetS( "kb2" ) ); + addKeyMap( pTerm, EXKEY_HOME, tiGetS( "ka1" ) ); + addKeyMap( pTerm, EXKEY_END, tiGetS( "kc1" ) ); + addKeyMap( pTerm, EXKEY_PGUP, tiGetS( "ka3" ) ); + addKeyMap( pTerm, EXKEY_PGDN, tiGetS( "kc3" ) ); /* other keys */ - addKeyMap( EXKEY_ENTER, tiGetS( "kent" ) ); - addKeyMap( EXKEY_END, tiGetS( "kend" ) ); - addKeyMap( EXKEY_PGUP, tiGetS( "kpp" ) ); - addKeyMap( EXKEY_PGDN, tiGetS( "knp" ) ); - addKeyMap( EXKEY_UP, tiGetS( "kcuu1" ) ); - addKeyMap( EXKEY_DOWN, tiGetS( "kcud1" ) ); - addKeyMap( EXKEY_RIGHT, tiGetS( "kcuf1" ) ); - addKeyMap( EXKEY_LEFT, tiGetS( "kcub1" ) ); - addKeyMap( EXKEY_HOME, tiGetS( "khome" ) ); - addKeyMap( EXKEY_INS, tiGetS( "kich1" ) ); - addKeyMap( EXKEY_DEL, tiGetS( "kdch1" ) ); - addKeyMap( EXKEY_TAB, tiGetS( "ht" ) ); - addKeyMap( EXKEY_BS, tiGetS( "kbs" ) ); + addKeyMap( pTerm, EXKEY_ENTER, tiGetS( "kent" ) ); + addKeyMap( pTerm, EXKEY_END, tiGetS( "kend" ) ); + addKeyMap( pTerm, EXKEY_PGUP, tiGetS( "kpp" ) ); + addKeyMap( pTerm, EXKEY_PGDN, tiGetS( "knp" ) ); + addKeyMap( pTerm, EXKEY_UP, tiGetS( "kcuu1" ) ); + addKeyMap( pTerm, EXKEY_DOWN, tiGetS( "kcud1" ) ); + addKeyMap( pTerm, EXKEY_RIGHT, tiGetS( "kcuf1" ) ); + addKeyMap( pTerm, EXKEY_LEFT, tiGetS( "kcub1" ) ); + addKeyMap( pTerm, EXKEY_HOME, tiGetS( "khome" ) ); + addKeyMap( pTerm, EXKEY_INS, tiGetS( "kich1" ) ); + addKeyMap( pTerm, EXKEY_DEL, tiGetS( "kdch1" ) ); + addKeyMap( pTerm, EXKEY_TAB, tiGetS( "ht" ) ); + addKeyMap( pTerm, EXKEY_BS, tiGetS( "kbs" ) ); - addKeyMap( EXKEY_TAB | KEY_ALTMASK, tiGetS( "kcbt" ) ); + addKeyMap( pTerm, EXKEY_TAB | KEY_ALTMASK, tiGetS( "kcbt" ) ); /* function keys */ - addKeyMap( EXKEY_F1, tiGetS( "kf1" ) ); - addKeyMap( EXKEY_F2, tiGetS( "kf2" ) ); - addKeyMap( EXKEY_F3, tiGetS( "kf3" ) ); - addKeyMap( EXKEY_F4, tiGetS( "kf4" ) ); - addKeyMap( EXKEY_F5, tiGetS( "kf5" ) ); - addKeyMap( EXKEY_F6, tiGetS( "kf6" ) ); - addKeyMap( EXKEY_F7, tiGetS( "kf7" ) ); - addKeyMap( EXKEY_F8, tiGetS( "kf8" ) ); - addKeyMap( EXKEY_F9, tiGetS( "kf9" ) ); - addKeyMap( EXKEY_F10, tiGetS( "kf10" ) ); - addKeyMap( EXKEY_F11, tiGetS( "kf11" ) ); - addKeyMap( EXKEY_F12, tiGetS( "kf12" ) ); + addKeyMap( pTerm, EXKEY_F1, tiGetS( "kf1" ) ); + addKeyMap( pTerm, EXKEY_F2, tiGetS( "kf2" ) ); + addKeyMap( pTerm, EXKEY_F3, tiGetS( "kf3" ) ); + addKeyMap( pTerm, EXKEY_F4, tiGetS( "kf4" ) ); + addKeyMap( pTerm, EXKEY_F5, tiGetS( "kf5" ) ); + addKeyMap( pTerm, EXKEY_F6, tiGetS( "kf6" ) ); + addKeyMap( pTerm, EXKEY_F7, tiGetS( "kf7" ) ); + addKeyMap( pTerm, EXKEY_F8, tiGetS( "kf8" ) ); + addKeyMap( pTerm, EXKEY_F9, tiGetS( "kf9" ) ); + addKeyMap( pTerm, EXKEY_F10, tiGetS( "kf10" ) ); + addKeyMap( pTerm, EXKEY_F11, tiGetS( "kf11" ) ); + addKeyMap( pTerm, EXKEY_F12, tiGetS( "kf12" ) ); /* shifted function keys */ - addKeyMap( EXKEY_F1 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf13" ) ); - addKeyMap( EXKEY_F2 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf14" ) ); - addKeyMap( EXKEY_F3 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf15" ) ); - addKeyMap( EXKEY_F4 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf16" ) ); - addKeyMap( EXKEY_F5 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf17" ) ); - addKeyMap( EXKEY_F6 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf18" ) ); - addKeyMap( EXKEY_F7 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf19" ) ); - addKeyMap( EXKEY_F8 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf20" ) ); - addKeyMap( EXKEY_F9 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf21" ) ); - addKeyMap( EXKEY_F10|KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf22" ) ); - addKeyMap( EXKEY_F11|KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf23" ) ); - addKeyMap( EXKEY_F12|KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf24" ) ); + addKeyMap( pTerm, EXKEY_F1 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf13" ) ); + addKeyMap( pTerm, EXKEY_F2 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf14" ) ); + addKeyMap( pTerm, EXKEY_F3 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf15" ) ); + addKeyMap( pTerm, EXKEY_F4 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf16" ) ); + addKeyMap( pTerm, EXKEY_F5 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf17" ) ); + addKeyMap( pTerm, EXKEY_F6 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf18" ) ); + addKeyMap( pTerm, EXKEY_F7 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf19" ) ); + addKeyMap( pTerm, EXKEY_F8 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf20" ) ); + addKeyMap( pTerm, EXKEY_F9 |KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf21" ) ); + addKeyMap( pTerm, EXKEY_F10|KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf22" ) ); + addKeyMap( pTerm, EXKEY_F11|KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf23" ) ); + addKeyMap( pTerm, EXKEY_F12|KEY_CTRLMASK|KEY_ALTMASK, tiGetS( "kf24" ) ); #endif } -static void hb_gt_trm_SetTerm( void ) +static void hb_gt_trm_SetTerm( PHB_GTTRM pTerm ) { static const char * szAcsc = "``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~"; static const char * szExtAcsc = "+\020,\021-\030.\0310\333`\004a\261f\370g\361h\260i\316j\331k\277l\332m\300n\305o~p\304q\304r\304s_t\303u\264v\301w\302x\263y\363z\362{\343|\330}\234~\376"; char * szTerm; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_SetTerm()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_SetTerm(%p)", pTerm)); - if( s_termState.iOutBufSize == 0 ) + if( pTerm->iOutBufSize == 0 ) { - s_termState.iOutBufIndex = 0; - s_termState.iOutBufSize = 16384; - s_termState.pOutBuf = ( BYTE * ) hb_xgrab( s_termState.iOutBufSize ); + pTerm->iOutBufIndex = 0; + pTerm->iOutBufSize = 16384; + pTerm->pOutBuf = ( BYTE * ) hb_xgrab( pTerm->iOutBufSize ); } - s_termState.mouse_type = MOUSE_NONE; - s_termState.esc_delay = ESC_DELAY; - s_termState.iAttrMask = ~0; + pTerm->mouse_type = MOUSE_NONE; + pTerm->esc_delay = ESC_DELAY; + pTerm->iAttrMask = ~0; szTerm = getenv("HB_TERM"); if( szTerm == NULL || *szTerm == '\0' ) @@ -2727,105 +2742,109 @@ static void hb_gt_trm_SetTerm( void ) strcmp( szTerm, "tterm" ) == 0 || strcmp( szTerm, "teraterm" ) == 0 ) { - s_termState.Init = hb_gt_trm_AnsiInit; - s_termState.Exit = hb_gt_trm_AnsiExit; - s_termState.SetTermMode = hb_gt_trm_LinuxSetTermMode; - s_termState.GetCursorPos = hb_gt_trm_AnsiGetCursorPos; - s_termState.SetCursorPos = hb_gt_trm_AnsiSetCursorPos; - s_termState.SetCursorStyle = hb_gt_trm_LinuxSetCursorStyle; - s_termState.SetAttributes = hb_gt_trm_AnsiSetAttributes; - s_termState.SetMode = hb_gt_trm_AnsiSetMode; - s_termState.GetAcsc = hb_gt_trm_AnsiGetAcsc; - s_termState.Tone = hb_gt_trm_LinuxTone; - s_termState.Bell = hb_gt_trm_AnsiBell; - s_termState.szAcsc = szExtAcsc; - s_termState.terminal_type = TERM_LINUX; + pTerm->Init = hb_gt_trm_AnsiInit; + pTerm->Exit = hb_gt_trm_AnsiExit; + pTerm->SetTermMode = hb_gt_trm_LinuxSetTermMode; + pTerm->GetCursorPos = hb_gt_trm_AnsiGetCursorPos; + pTerm->SetCursorPos = hb_gt_trm_AnsiSetCursorPos; + pTerm->SetCursorStyle = hb_gt_trm_LinuxSetCursorStyle; + pTerm->SetAttributes = hb_gt_trm_AnsiSetAttributes; + pTerm->SetMode = hb_gt_trm_AnsiSetMode; + pTerm->GetAcsc = hb_gt_trm_AnsiGetAcsc; + pTerm->Tone = hb_gt_trm_LinuxTone; + pTerm->Bell = hb_gt_trm_AnsiBell; + pTerm->szAcsc = szExtAcsc; + pTerm->terminal_type = TERM_LINUX; } else if( strstr( szTerm, "xterm" ) != NULL || strncmp( szTerm, "rxvt", 4 ) == 0 || strcmp( szTerm, "putty" ) == 0 || strncmp( szTerm, "screen", 6 ) == 0 ) { - s_termState.Init = hb_gt_trm_AnsiInit; - s_termState.Exit = hb_gt_trm_AnsiExit; - s_termState.SetTermMode = hb_gt_trm_LinuxSetTermMode; - s_termState.GetCursorPos = hb_gt_trm_AnsiGetCursorPos; - s_termState.SetCursorPos = hb_gt_trm_AnsiSetCursorPos; - s_termState.SetCursorStyle = hb_gt_trm_AnsiSetCursorStyle; - s_termState.SetAttributes = hb_gt_trm_XtermSetAttributes; - s_termState.SetMode = hb_gt_trm_XtermSetMode; - s_termState.GetAcsc = hb_gt_trm_AnsiGetAcsc; - s_termState.Tone = hb_gt_trm_AnsiTone; - s_termState.Bell = hb_gt_trm_AnsiBell; - s_termState.szAcsc = szAcsc; - s_termState.terminal_type = TERM_XTERM; + pTerm->Init = hb_gt_trm_AnsiInit; + pTerm->Exit = hb_gt_trm_AnsiExit; + pTerm->SetTermMode = hb_gt_trm_LinuxSetTermMode; + pTerm->GetCursorPos = hb_gt_trm_AnsiGetCursorPos; + pTerm->SetCursorPos = hb_gt_trm_AnsiSetCursorPos; + pTerm->SetCursorStyle = hb_gt_trm_AnsiSetCursorStyle; + pTerm->SetAttributes = hb_gt_trm_XtermSetAttributes; + pTerm->SetMode = hb_gt_trm_XtermSetMode; + pTerm->GetAcsc = hb_gt_trm_AnsiGetAcsc; + pTerm->Tone = hb_gt_trm_AnsiTone; + pTerm->Bell = hb_gt_trm_AnsiBell; + pTerm->szAcsc = szAcsc; + pTerm->terminal_type = TERM_XTERM; } else { - s_termState.Init = hb_gt_trm_AnsiInit; - s_termState.Exit = hb_gt_trm_AnsiExit; - s_termState.SetTermMode = hb_gt_trm_AnsiSetTermMode; - s_termState.GetCursorPos = hb_gt_trm_AnsiGetCursorPos; - s_termState.SetCursorPos = hb_gt_trm_AnsiSetCursorPos; - s_termState.SetCursorStyle = hb_gt_trm_AnsiSetCursorStyle; - s_termState.SetAttributes = hb_gt_trm_AnsiSetAttributes; - s_termState.SetMode = hb_gt_trm_AnsiSetMode; - s_termState.GetAcsc = hb_gt_trm_AnsiGetAcsc; - s_termState.Tone = hb_gt_trm_AnsiTone; - s_termState.Bell = hb_gt_trm_AnsiBell; - s_termState.szAcsc = szExtAcsc; - s_termState.terminal_type = TERM_ANSI; + pTerm->Init = hb_gt_trm_AnsiInit; + pTerm->Exit = hb_gt_trm_AnsiExit; + pTerm->SetTermMode = hb_gt_trm_AnsiSetTermMode; + pTerm->GetCursorPos = hb_gt_trm_AnsiGetCursorPos; + pTerm->SetCursorPos = hb_gt_trm_AnsiSetCursorPos; + pTerm->SetCursorStyle = hb_gt_trm_AnsiSetCursorStyle; + pTerm->SetAttributes = hb_gt_trm_AnsiSetAttributes; + pTerm->SetMode = hb_gt_trm_AnsiSetMode; + pTerm->GetAcsc = hb_gt_trm_AnsiGetAcsc; + pTerm->Tone = hb_gt_trm_AnsiTone; + pTerm->Bell = hb_gt_trm_AnsiBell; + pTerm->szAcsc = szExtAcsc; + pTerm->terminal_type = TERM_ANSI; } - s_termState.fStdinTTY = hb_fsIsDevice( s_termState.hFilenoStdin ); - s_termState.fStdoutTTY = hb_fsIsDevice( s_termState.hFilenoStdout ); - s_termState.fStderrTTY = hb_fsIsDevice( s_termState.hFilenoStderr ); - s_termState.hFileno = s_termState.hFilenoStdout; - s_termState.fOutTTY = s_termState.fStdoutTTY; - if( !s_termState.fOutTTY && s_termState.fStdinTTY ) + pTerm->fStdinTTY = hb_fsIsDevice( pTerm->hFilenoStdin ); + pTerm->fStdoutTTY = hb_fsIsDevice( pTerm->hFilenoStdout ); + pTerm->fStderrTTY = hb_fsIsDevice( pTerm->hFilenoStderr ); + pTerm->hFileno = pTerm->hFilenoStdout; + pTerm->fOutTTY = pTerm->fStdoutTTY; + if( !pTerm->fOutTTY && pTerm->fStdinTTY ) { - s_termState.hFileno = s_termState.hFilenoStdin; - s_termState.fOutTTY = TRUE; + pTerm->hFileno = pTerm->hFilenoStdin; + pTerm->fOutTTY = TRUE; } - s_termState.fPosAnswer = s_termState.fOutTTY; - s_termState.fUTF8 = FALSE; + pTerm->fPosAnswer = pTerm->fOutTTY; + pTerm->fUTF8 = FALSE; - hb_fsSetDevMode( s_termState.hFileno, FD_BINARY ); + hb_fsSetDevMode( pTerm->hFileno, FD_BINARY ); - hb_gt_chrmapinit( s_termState.charmap, szTerm, s_termState.terminal_type == TERM_XTERM ); + hb_gt_chrmapinit( pTerm->charmap, szTerm, pTerm->terminal_type == TERM_XTERM ); #ifndef HB_CDP_SUPPORT_OFF - s_termState.cdpHost = s_termState.cdpOut = s_termState.cdpIn = NULL; - s_termState.cdpEN = hb_cdpFind( "EN" ); + pTerm->cdpHost = pTerm->cdpOut = pTerm->cdpIn = NULL; + pTerm->cdpEN = hb_cdpFind( "EN" ); #endif - add_efds( s_termState.hFilenoStdin, O_RDONLY, NULL, NULL ); - init_keys(); - mouse_init(); + add_efds( pTerm, pTerm->hFilenoStdin, O_RDONLY, NULL, NULL ); + init_keys( pTerm ); + mouse_init( pTerm ); } -static void hb_gt_trm_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) +static void hb_gt_trm_Init( PHB_GT pGT, FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) { int iRows = 24, iCols = 80; + PHB_GTTRM pTerm; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_Init(%p,%p,%p)", hFilenoStdin, hFilenoStdout, hFilenoStderr)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_Init(%p,%p,%p,%p)", pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr)); - memset( &s_termState, 0, sizeof( s_termState ) ); - s_termState.hFilenoStdin = hFilenoStdin; - s_termState.hFilenoStdout = hFilenoStdout; - s_termState.hFilenoStderr = hFilenoStderr; + pTerm = ( PHB_GTTRM ) hb_xgrab( sizeof( HB_GTTRM ) ); + memset( pTerm, 0, sizeof( HB_GTTRM ) ); + HB_GTLOCAL( pGT ) = pTerm; + pTerm->pGT = pGT; + pTerm->hFilenoStdin = hFilenoStdin; + pTerm->hFilenoStdout = hFilenoStdout; + pTerm->hFilenoStderr = hFilenoStderr; - hb_gt_trm_SetTerm(); + hb_gt_trm_SetTerm( pTerm ); /* SA_NOCLDSTOP in #if is a hack to detect POSIX compatible environment */ #if defined( OS_UNIX_COMPATIBLE ) && defined( SA_NOCLDSTOP ) - if( s_termState.fStdinTTY ) + if( pTerm->fStdinTTY ) { struct sigaction act, old; - s_termState.fRestTTY = TRUE; + s_fRestTTY = TRUE; - /* if( s_termState.saved_TIO.c_lflag & TOSTOP ) != 0 */ + /* if( pTerm->saved_TIO.c_lflag & TOSTOP ) != 0 */ sigaction( SIGTTOU, NULL, &old ); memcpy( &act, &old, sizeof( struct sigaction ) ); act.sa_handler = sig_handler; @@ -2839,143 +2858,159 @@ static void hb_gt_trm_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE #endif sigaction( SIGTTOU, &act, 0 ); - tcgetattr( s_termState.hFilenoStdin, &s_termState.saved_TIO ); - memcpy( &s_termState.curr_TIO, &s_termState.saved_TIO, sizeof( struct termios ) ); + tcgetattr( pTerm->hFilenoStdin, &pTerm->saved_TIO ); + memcpy( &pTerm->curr_TIO, &pTerm->saved_TIO, sizeof( struct termios ) ); /* atexit( restore_input_mode ); */ - s_termState.curr_TIO.c_lflag &= ~( ECHO | ECHONL | ICANON | ISIG | IEXTEN ); - s_termState.curr_TIO.c_lflag |= NOFLSH; - s_termState.curr_TIO.c_cflag &= ~( CSIZE | PARENB ); - s_termState.curr_TIO.c_cflag |= CS8 | CREAD; - s_termState.curr_TIO.c_iflag &= ~( IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON ); - s_termState.curr_TIO.c_oflag &= ~OPOST; + pTerm->curr_TIO.c_lflag &= ~( ECHO | ECHONL | ICANON | ISIG | IEXTEN ); + pTerm->curr_TIO.c_lflag |= NOFLSH; + pTerm->curr_TIO.c_cflag &= ~( CSIZE | PARENB ); + pTerm->curr_TIO.c_cflag |= CS8 | CREAD; + pTerm->curr_TIO.c_iflag &= ~( IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON ); + pTerm->curr_TIO.c_oflag &= ~OPOST; /* Enable LF->CR+LF translation */ - s_termState.curr_TIO.c_oflag = ONLCR | OPOST; + pTerm->curr_TIO.c_oflag = ONLCR | OPOST; - memset( s_termState.curr_TIO.c_cc, 0, NCCS ); - /* s_termState.curr_TIO.c_cc[ VMIN ] = 0; */ - /* s_termState.curr_TIO.c_cc[ VTIME ] = 0; */ - tcsetattr( s_termState.hFilenoStdin, TCSAFLUSH, &s_termState.curr_TIO ); + memset( pTerm->curr_TIO.c_cc, 0, NCCS ); + /* pTerm->curr_TIO.c_cc[ VMIN ] = 0; */ + /* pTerm->curr_TIO.c_cc[ VTIME ] = 0; */ + tcsetattr( pTerm->hFilenoStdin, TCSAFLUSH, &pTerm->curr_TIO ); act.sa_handler = SIG_DFL; sigaction( SIGTTOU, &old, 0 ); + pTerm->fRestTTY = s_fRestTTY; } set_signals(); - if( ! hb_gt_trm_getSize( &iRows, &iCols ) ) + if( ! hb_gt_trm_getSize( pTerm, &iRows, &iCols ) ) { iRows = 24; iCols = 80; } #endif - HB_GTSUPER_INIT( hFilenoStdin, hFilenoStdout, hFilenoStderr ); - HB_GTSUPER_RESIZE( iRows, iCols ); - hb_gt_SetFlag( GTI_COMPATBUFFER, FALSE ); - hb_gt_SetFlag( GTI_STDOUTCON, s_termState.fStdoutTTY ); - hb_gt_SetFlag( GTI_STDERRCON, s_termState.fStderrTTY ); - hb_gt_SetBlink( TRUE ); + HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr ); + HB_GTSUPER_RESIZE( pGT, iRows, iCols ); + HB_GTSELF_SETFLAG( pGT, GTI_COMPATBUFFER, FALSE ); + HB_GTSELF_SETFLAG( pGT, GTI_STDOUTCON, pTerm->fStdoutTTY ); + HB_GTSELF_SETFLAG( pGT, GTI_STDERRCON, pTerm->fStderrTTY ); + HB_GTSELF_SETBLINK( pGT, TRUE ); - s_termState.Init(); - s_termState.SetTermMode( 0 ); - if( s_termState.GetCursorPos( &s_termState.iRow, &s_termState.iCol ) ) - hb_gt_SetPos( s_termState.iRow, s_termState.iCol ); - s_termState.fUTF8 = hb_trm_isUTF8(); - hb_gt_trm_SetKeyTrans( NULL, NULL ); - hb_gt_trm_SetDispTrans( NULL, NULL, 0 ); - if( s_termState.fOutTTY ) - hb_gt_SemiCold(); + pTerm->Init( pTerm ); + pTerm->SetTermMode( pTerm, 0 ); + if( pTerm->GetCursorPos( pTerm, &pTerm->iRow, &pTerm->iCol ) ) + HB_GTSELF_SETPOS( pGT, pTerm->iRow, pTerm->iCol ); + pTerm->fUTF8 = hb_trm_isUTF8( pTerm ); + hb_gt_trm_SetKeyTrans( pTerm, NULL, NULL ); + hb_gt_trm_SetDispTrans( pTerm, NULL, NULL, 0 ); + if( pTerm->fOutTTY ) + HB_GTSELF_SEMICOLD( pGT ); } -static void hb_gt_trm_Exit( void ) +static void hb_gt_trm_Exit( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_Exit()")); + PHB_GTTRM pTerm; - hb_gt_Refresh(); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_Exit(%p)", pGT)); - mouse_exit(); - del_all_efds(); - if( s_termState.pKeyTab ) - removeAllKeyMap( &s_termState.pKeyTab ); + HB_GTSELF_REFRESH( pGT ); - s_termState.Exit(); - if( s_termState.fOutTTY && s_termState.iCol > 0 ) - hb_gt_trm_termOut( ( BYTE * ) "\n\r", 2 ); - hb_gt_trm_termFlush(); + pTerm = HB_GTTRM_GET( pGT ); + if( pTerm ) + { + mouse_exit( pTerm ); + del_all_efds( pTerm ); + if( pTerm->pKeyTab ) + removeAllKeyMap( pTerm, &pTerm->pKeyTab ); - HB_GTSUPER_EXIT(); + pTerm->Exit( pTerm ); + if( pTerm->fOutTTY && pTerm->iCol > 0 ) + hb_gt_trm_termOut( pTerm, ( BYTE * ) "\n\r", 2 ); + hb_gt_trm_termFlush( pTerm ); + } + HB_GTSUPER_EXIT( pGT ); + + if( pTerm ) + { #if defined( OS_UNIX_COMPATIBLE ) - if( s_termState.fRestTTY ) - tcsetattr( s_termState.hFilenoStdin, TCSANOW, &s_termState.saved_TIO ); + if( pTerm->fRestTTY ) + tcsetattr( pTerm->hFilenoStdin, TCSANOW, &pTerm->saved_TIO ); #endif - if( s_termState.iLineBufSize > 0 ) - { - hb_xfree( s_termState.pLineBuf ); - s_termState.iLineBufSize = 0; + if( pTerm->iLineBufSize > 0 ) + hb_xfree( pTerm->pLineBuf ); + if( pTerm->iOutBufSize > 0 ) + hb_xfree( pTerm->pOutBuf ); + hb_xfree( pTerm ); } - if( s_termState.iOutBufSize > 0 ) - { - hb_xfree( s_termState.pOutBuf ); - s_termState.iOutBufSize = s_termState.iOutBufIndex = 0; - } - s_termState.fStdinTTY = s_termState.fStdoutTTY = s_termState.fStderrTTY = - s_termState.fOutTTY = FALSE; } -static BOOL hb_gt_trm_mouse_IsPresent( void ) +static BOOL hb_gt_trm_mouse_IsPresent( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_mouse_IsPresent()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_mouse_IsPresent(%p)", pGT ) ); - return s_termState.mouse_type != MOUSE_NONE; + return HB_GTTRM_GET( pGT )->mouse_type != MOUSE_NONE; } -static void hb_gt_trm_mouse_Show( void ) +static void hb_gt_trm_mouse_Show( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_mouse_Show()" ) ); + PHB_GTTRM pTerm; + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_mouse_Show(%p)", pGT ) ); + + pTerm = HB_GTTRM_GET( pGT ); #ifdef HAVE_GPM_H - if( s_termState.mouse_type & MOUSE_GPM ) + if( pTerm->mouse_type & MOUSE_GPM ) gpm_visiblepointer = 1; #endif - disp_mousecursor(); + disp_mousecursor( pTerm ); } -static void hb_gt_trm_mouse_Hide( void ) +static void hb_gt_trm_mouse_Hide( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_mouse_Hide()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_mouse_Hide(%p)", pGT ) ); #ifdef HAVE_GPM_H - if( s_termState.mouse_type & MOUSE_GPM ) + if( HB_GTTRM_GET( pGT )->mouse_type & MOUSE_GPM ) { gpm_visiblepointer = 0; } +#else + HB_SYMBOL_UNUSED( pGT ); #endif } -static void hb_gt_trm_mouse_GetPos( int * piRow, int * piCol ) +static void hb_gt_trm_mouse_GetPos( PHB_GT pGT, int * piRow, int * piCol ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_mouse_Col(%p,%p)", piRow, piCol ) ); + PHB_GTTRM pTerm; - *piRow = s_termState.mLastEvt.row; - *piCol = s_termState.mLastEvt.col; + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_mouse_Col(%p,%p,%p)", pGT, piRow, piCol ) ); + + pTerm = HB_GTTRM_GET( pGT ); + *piRow = pTerm->mLastEvt.row; + *piCol = pTerm->mLastEvt.col; } -static void hb_gt_trm_mouse_SetPos( int iRow, int iCol ) +static void hb_gt_trm_mouse_SetPos( PHB_GT pGT, int iRow, int iCol ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_mouse_SetPos(%i, %i)", iRow, iCol ) ); + PHB_GTTRM pTerm; + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_mouse_SetPos(%p,%i,%i)", pGT, iRow, iCol ) ); + + pTerm = HB_GTTRM_GET( pGT ); /* it does really nothing */ - s_termState.mLastEvt.col = iCol; - s_termState.mLastEvt.row = iRow; - disp_mousecursor(); + pTerm->mLastEvt.col = iCol; + pTerm->mLastEvt.row = iRow; + disp_mousecursor( pTerm ); } -static BOOL hb_gt_trm_mouse_ButtonState( int iButton ) +static BOOL hb_gt_trm_mouse_ButtonState( PHB_GT pGT, int iButton ) { + PHB_GTTRM pTerm; BOOL ret = FALSE; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_mouse_ButtonState(%i)", iButton ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_mouse_ButtonState(%p,%i)", pGT, iButton ) ); - if( s_termState.mouse_type != MOUSE_NONE ) + pTerm = HB_GTTRM_GET( pGT ); + if( pTerm->mouse_type != MOUSE_NONE ) { int mask; @@ -2988,58 +3023,66 @@ static BOOL hb_gt_trm_mouse_ButtonState( int iButton ) else mask = 0; - ret = ( s_termState.mLastEvt.buttonstate & mask ) != 0; + ret = ( pTerm->mLastEvt.buttonstate & mask ) != 0; } return ret; } -static int hb_gt_trm_mouse_CountButton( void ) +static int hb_gt_trm_mouse_CountButton( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_mouse_CountButton()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_mouse_CountButton(%p)", pGT ) ); - return s_termState.mButtons; + return HB_GTTRM_GET( pGT )->mButtons; } -static int hb_gt_trm_ReadKey( int iEventMask ) +static int hb_gt_trm_ReadKey( PHB_GT pGT, int iEventMask ) { int iKey; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_ReadKey(%d)", iEventMask)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_ReadKey(%p,%d)", pGT, iEventMask)); HB_SYMBOL_UNUSED( iEventMask ); - iKey = wait_key( -1 ); + iKey = wait_key( HB_GTTRM_GET( pGT ), -1 ); if( iKey == K_RESIZE ) { int iRows, iCols; - if( hb_gt_trm_getSize( &iRows, &iCols ) ) - HB_GTSUPER_RESIZE( iRows, iCols ); + if( hb_gt_trm_getSize( HB_GTTRM_GET( pGT ), &iRows, &iCols ) ) + HB_GTSUPER_RESIZE( pGT, iRows, iCols ); iKey = 0; } return iKey; } -static void hb_gt_trm_Tone( double dFrequency, double dDuration ) +static void hb_gt_trm_Tone( PHB_GT pGT, double dFrequency, double dDuration ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_Tone(%lf, %lf)", dFrequency, dDuration)); + PHB_GTTRM pTerm; - s_termState.Tone( dFrequency, dDuration ); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_trm_Tone(%p,%lf,%lf)", pGT, dFrequency, dDuration)); + + pTerm = HB_GTTRM_GET( pGT ); + pTerm->Tone( pTerm, dFrequency, dDuration ); } -static void hb_gt_trm_Bell( void ) +static void hb_gt_trm_Bell( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ( "hb_gt_trm_Bell()" ) ); + PHB_GTTRM pTerm; - s_termState.Bell(); + HB_TRACE(HB_TR_DEBUG, ( "hb_gt_trm_Bell(%p)", pGT ) ); + + pTerm = HB_GTTRM_GET( pGT ); + pTerm->Bell( pTerm ); } -static char * hb_gt_trm_Version( int iType ) +static char * hb_gt_trm_Version( PHB_GT pGT, int iType ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_Version(%d)", iType ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_Version(%p,%d)", pGT, iType ) ); + + HB_SYMBOL_UNUSED( pGT ); if( iType == 0 ) return HB_GT_DRVNAME( HB_GT_NAME ); @@ -3047,103 +3090,111 @@ static char * hb_gt_trm_Version( int iType ) return "Harbour terminal driver"; } -static BOOL hb_gt_trm_Suspend( void ) +static BOOL hb_gt_trm_Suspend( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_Suspend()" ) ); + PHB_GTTRM pTerm; + + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_Suspend(%p)", pGT ) ); + + pTerm = HB_GTTRM_GET( pGT ); #if defined( OS_UNIX_COMPATIBLE ) - if( s_termState.fRestTTY ) - { - tcsetattr( s_termState.hFilenoStdin, TCSANOW, &s_termState.saved_TIO ); - } + if( pTerm->fRestTTY ) + tcsetattr( pTerm->hFilenoStdin, TCSANOW, &pTerm->saved_TIO ); #endif /* Enable line wrap when cursor set after last column */ - s_termState.SetTermMode( 1 ); + pTerm->SetTermMode( pTerm, 1 ); return TRUE; } -static BOOL hb_gt_trm_Resume( void ) +static BOOL hb_gt_trm_Resume( PHB_GT pGT ) { + PHB_GTTRM pTerm; int iHeight, iWidth; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_Resume()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_Resume(%p)", pGT ) ); + pTerm = HB_GTTRM_GET( pGT ); #if defined( OS_UNIX_COMPATIBLE ) - if( s_termState.fRestTTY ) - { - tcsetattr( s_termState.hFilenoStdin, TCSANOW, &s_termState.curr_TIO ); - } + if( pTerm->fRestTTY ) + tcsetattr( pTerm->hFilenoStdin, TCSANOW, &pTerm->curr_TIO ); #endif + if( pTerm->mouse_type & MOUSE_XTERM ) + hb_gt_trm_termOut( pTerm, ( BYTE * ) s_szMouseOn, strlen( s_szMouseOn ) ); - if( s_termState.mouse_type & MOUSE_XTERM ) - hb_gt_trm_termOut( ( BYTE * ) s_szMouseOn, strlen( s_szMouseOn ) ); + pTerm->Init( pTerm ); - s_termState.Init(); + HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth ); + HB_GTSELF_EXPOSEAREA( pGT, 0, 0, iHeight, iWidth ); - hb_gt_GetSize( &iHeight, &iWidth ); - hb_gt_ExposeArea( 0, 0, iHeight, iWidth ); - - hb_gt_Refresh(); + HB_GTSELF_REFRESH( pGT ); return TRUE; } -static void hb_gt_trm_Scroll( int iTop, int iLeft, int iBottom, int iRight, +static void hb_gt_trm_Scroll( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE bColor, BYTE bChar, int iRows, int iCols ) { - int iHeight, iWidth; - - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_std_Scroll(%d,%d,%d,%d,%d,%d,%d,%d)", iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_Scroll(%p,%d,%d,%d,%d,%d,%d,%d,%d)", pGT, iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols ) ); /* Provide some basic scroll support for full screen */ if( iCols == 0 && iRows > 0 && iTop == 0 && iLeft == 0 ) { - hb_gt_GetSize( &iHeight, &iWidth ); + PHB_GTTRM pTerm = HB_GTTRM_GET( pGT ); + int iHeight, iWidth; + + HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth ); if( iBottom >= iHeight - 1 && iRight >= iWidth - 1 && - s_termState.iRow == iHeight - 1 ) + pTerm->iRow == iHeight - 1 ) { /* scroll up the internal screen buffer */ - HB_GTSUPER_SCROLLUP( iRows, bColor, bChar ); + HB_GTSUPER_SCROLLUP( pGT, iRows, bColor, bChar ); /* update our internal row position */ do - hb_gt_trm_termOut( ( BYTE * ) "\n\r", 2 ); + hb_gt_trm_termOut( pTerm, ( BYTE * ) "\n\r", 2 ); while( --iRows > 0 ); - s_termState.iCol = 0; + pTerm->iCol = 0; return; } } - HB_GTSUPER_SCROLL( iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols ); + HB_GTSUPER_SCROLL( pGT, iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols ); } -static BOOL hb_gt_trm_SetMode( int iRows, int iCols ) +static BOOL hb_gt_trm_SetMode( PHB_GT pGT, int iRows, int iCols ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_SetMode(%d, %d)", iRows, iCols ) ); + PHB_GTTRM pTerm; - if( s_termState.SetMode( &iRows, &iCols ) ) + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_SetMode(%p,%d,%d)", pGT, iRows, iCols ) ); + + pTerm = HB_GTTRM_GET( pGT ); + if( pTerm->SetMode( pTerm, &iRows, &iCols ) ) { - HB_GTSUPER_RESIZE( iRows, iCols ); + HB_GTSUPER_RESIZE( pGT, iRows, iCols ); return TRUE; } return FALSE; } -static void hb_gt_trm_SetBlink( BOOL fBlink ) +static void hb_gt_trm_SetBlink( PHB_GT pGT, BOOL fBlink ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_SetBlink(%d)", ( int ) fBlink ) ); + PHB_GTTRM pTerm; + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_SetBlink(%p,%d)", pGT, ( int ) fBlink ) ); + + pTerm = HB_GTTRM_GET( pGT ); if( fBlink ) - s_termState.iAttrMask |= 0x0080; + pTerm->iAttrMask |= 0x0080; else - s_termState.iAttrMask &= ~0x0080; + pTerm->iAttrMask &= ~0x0080; - HB_GTSUPER_SETBLINK( fBlink ); + HB_GTSUPER_SETBLINK( pGT, fBlink ); } -static BOOL hb_gt_trm_SetDispCP( char *pszTermCDP, char *pszHostCDP, BOOL fBox ) +static BOOL hb_gt_trm_SetDispCP( PHB_GT pGT, char *pszTermCDP, char *pszHostCDP, BOOL fBox ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_SetDispCP(%s,%s,%d)", pszTermCDP, pszHostCDP, (int) fBox ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_SetDispCP(%p,%s,%s,%d)", pGT, pszTermCDP, pszHostCDP, (int) fBox ) ); - HB_GTSUPER_SETDISPCP( pszTermCDP, pszHostCDP, fBox ); + HB_GTSUPER_SETDISPCP( pGT, pszTermCDP, pszHostCDP, fBox ); #ifndef HB_CDP_SUPPORT_OFF if( !pszHostCDP ) @@ -3153,23 +3204,25 @@ static BOOL hb_gt_trm_SetDispCP( char *pszTermCDP, char *pszHostCDP, BOOL fBox ) if( pszTermCDP && pszHostCDP ) { - s_termState.cdpOut = hb_cdpFind( pszTermCDP ); - s_termState.cdpHost = hb_cdpFind( pszHostCDP ); + PHB_GTTRM pTerm = HB_GTTRM_GET( pGT ); - if( s_termState.cdpOut && s_termState.cdpHost && - s_termState.cdpHost->nChars && - s_termState.cdpHost->nChars == s_termState.cdpOut->nChars ) + pTerm->cdpOut = hb_cdpFind( pszTermCDP ); + pTerm->cdpHost = hb_cdpFind( pszHostCDP ); + + if( pTerm->cdpOut && pTerm->cdpHost && + pTerm->cdpHost->nChars && + pTerm->cdpHost->nChars == pTerm->cdpOut->nChars ) { - int iChars = s_termState.cdpHost->nChars; + int iChars = pTerm->cdpHost->nChars; char *pszHostLetters = ( char * ) hb_xgrab( iChars * 2 + 1 ); char *pszTermLetters = ( char * ) hb_xgrab( iChars * 2 + 1 ); - memcpy( pszHostLetters, s_termState.cdpHost->CharsUpper, iChars ); - memcpy( pszHostLetters + iChars, s_termState.cdpHost->CharsLower, iChars + 1 ); - memcpy( pszTermLetters, s_termState.cdpOut->CharsUpper, iChars ); - memcpy( pszTermLetters + iChars, s_termState.cdpOut->CharsLower, iChars + 1 ); + memcpy( pszHostLetters, pTerm->cdpHost->CharsUpper, iChars ); + memcpy( pszHostLetters + iChars, pTerm->cdpHost->CharsLower, iChars + 1 ); + memcpy( pszTermLetters, pTerm->cdpOut->CharsUpper, iChars ); + memcpy( pszTermLetters + iChars, pTerm->cdpOut->CharsLower, iChars + 1 ); - hb_gt_trm_SetDispTrans( pszHostLetters, pszTermLetters, fBox ? 1 : 0 ); + hb_gt_trm_SetDispTrans( pTerm, pszHostLetters, pszTermLetters, fBox ? 1 : 0 ); hb_xfree( pszHostLetters ); hb_xfree( pszTermLetters ); @@ -3181,9 +3234,9 @@ static BOOL hb_gt_trm_SetDispCP( char *pszTermCDP, char *pszHostCDP, BOOL fBox ) return FALSE; } -static BOOL hb_gt_trm_SetKeyCP( char *pszTermCDP, char *pszHostCDP ) +static BOOL hb_gt_trm_SetKeyCP( PHB_GT pGT, char *pszTermCDP, char *pszHostCDP ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_SetKeyCP(%s,%s)", pszTermCDP, pszHostCDP ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_SetKeyCP(%p,%s,%s)", pGT, pszTermCDP, pszHostCDP ) ); #ifndef HB_CDP_SUPPORT_OFF if( !pszHostCDP ) @@ -3193,6 +3246,7 @@ static BOOL hb_gt_trm_SetKeyCP( char *pszTermCDP, char *pszHostCDP ) if( pszTermCDP && pszHostCDP ) { + PHB_GTTRM pTerm = HB_GTTRM_GET( pGT ); PHB_CODEPAGE cdpTerm = hb_cdpFind( pszTermCDP ), cdpHost = hb_cdpFind( pszHostCDP ); if( cdpTerm && cdpHost && cdpTerm != cdpHost && @@ -3208,15 +3262,15 @@ static BOOL hb_gt_trm_SetKeyCP( char *pszTermCDP, char *pszHostCDP ) memcpy( pszTermLetters + cdpTerm->nChars, cdpTerm->CharsLower, cdpTerm->nChars ); pszTermLetters[ cdpTerm->nChars << 1 ] = '\0'; - hb_gt_trm_SetKeyTrans( pszTermLetters, pszHostLetters ); + hb_gt_trm_SetKeyTrans( pTerm, pszTermLetters, pszHostLetters ); hb_xfree( pszHostLetters ); hb_xfree( pszTermLetters ); } else - hb_gt_trm_SetKeyTrans( NULL, NULL ); + hb_gt_trm_SetKeyTrans( pTerm, NULL, NULL ); - s_termState.cdpIn = cdpTerm; + pTerm->cdpIn = cdpTerm; return TRUE; } @@ -3228,92 +3282,98 @@ static BOOL hb_gt_trm_SetKeyCP( char *pszTermCDP, char *pszHostCDP ) return FALSE; } -static void hb_gt_trm_Redraw( int iRow, int iCol, int iSize ) +static void hb_gt_trm_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize ) { + PHB_GTTRM pTerm; BYTE bColor, bAttr; USHORT usChar; int iLen = 0, iAttribute = 0, iColor; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_Redraw(%d, %d, %d)", iRow, iCol, iSize ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_Redraw(%p,%d,%d,%d)", pGT, iRow, iCol, iSize ) ); - s_termState.SetTermMode( 0 ); + pTerm = HB_GTTRM_GET( pGT ); + pTerm->SetTermMode( pTerm, 0 ); while( iSize-- ) { - if( !hb_gt_GetScrChar( iRow, iCol + iLen, &bColor, &bAttr, &usChar ) ) + if( !HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol + iLen, &bColor, &bAttr, &usChar ) ) break; usChar &= 0xff; if( bAttr & HB_GT_ATTR_BOX ) { - iColor = bColor | ( s_termState.boxattr[ usChar ] & ~HB_GTTRM_ATTR_CHAR ); - if( !s_termState.fUTF8 ) - usChar = s_termState.boxattr[ usChar ] & HB_GTTRM_ATTR_CHAR; + iColor = bColor | ( pTerm->boxattr[ usChar ] & ~HB_GTTRM_ATTR_CHAR ); + if( !pTerm->fUTF8 ) + usChar = pTerm->boxattr[ usChar ] & HB_GTTRM_ATTR_CHAR; } else { - iColor = bColor | ( s_termState.chrattr[ usChar ] & ~HB_GTTRM_ATTR_CHAR ); - if( !s_termState.fUTF8 ) - usChar = s_termState.chrattr[ usChar ] & HB_GTTRM_ATTR_CHAR; + iColor = bColor | ( pTerm->chrattr[ usChar ] & ~HB_GTTRM_ATTR_CHAR ); + if( !pTerm->fUTF8 ) + usChar = pTerm->chrattr[ usChar ] & HB_GTTRM_ATTR_CHAR; } if( iLen == 0 ) iAttribute = iColor; else if( iColor != iAttribute ) { - hb_gt_trm_PutStr( iRow, iCol, iAttribute, s_termState.pLineBuf, iLen ); + hb_gt_trm_PutStr( pTerm, iRow, iCol, iAttribute, pTerm->pLineBuf, iLen ); iCol += iLen; iLen = 0; iAttribute = iColor; } - s_termState.pLineBuf[ iLen++ ] = ( BYTE ) usChar; + pTerm->pLineBuf[ iLen++ ] = ( BYTE ) usChar; } if( iLen ) { - hb_gt_trm_PutStr( iRow, iCol, iAttribute, s_termState.pLineBuf, iLen ); + hb_gt_trm_PutStr( pTerm, iRow, iCol, iAttribute, pTerm->pLineBuf, iLen ); } } -static void hb_gt_trm_Refresh( void ) +static void hb_gt_trm_Refresh( PHB_GT pGT ) { int iWidth, iHeight, iRow, iCol, iStyle; + PHB_GTTRM pTerm; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_Refresh()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_Refresh(%p)", pGT ) ); - hb_gt_GetSize( &iHeight, &iWidth ); + HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth ); - if( s_termState.iLineBufSize == 0 ) + pTerm = HB_GTTRM_GET( pGT ); + if( pTerm->iLineBufSize == 0 ) { - s_termState.pLineBuf = ( BYTE * ) hb_xgrab( iWidth ); - s_termState.iLineBufSize = iWidth; + pTerm->pLineBuf = ( BYTE * ) hb_xgrab( iWidth ); + pTerm->iLineBufSize = iWidth; } - else if( s_termState.iLineBufSize != iWidth ) + else if( pTerm->iLineBufSize != iWidth ) { - s_termState.pLineBuf = ( BYTE * ) hb_xrealloc( s_termState.pLineBuf, iWidth ); - s_termState.iLineBufSize = iWidth; + pTerm->pLineBuf = ( BYTE * ) hb_xrealloc( pTerm->pLineBuf, iWidth ); + pTerm->iLineBufSize = iWidth; } - HB_GTSUPER_REFRESH(); + HB_GTSUPER_REFRESH( pGT ); - hb_gt_GetScrCursor( &iRow, &iCol, &iStyle ); + HB_GTSELF_GETSCRCURSOR( pGT, &iRow, &iCol, &iStyle ); if( iStyle != SC_NONE ) { if( iRow >= 0 && iCol >= 0 && iRow < iHeight && iCol < iWidth ) - s_termState.SetCursorPos( iRow, iCol ); + pTerm->SetCursorPos( pTerm, iRow, iCol ); else iStyle = SC_NONE; } - s_termState.SetCursorStyle( iStyle ); - disp_mousecursor(); - hb_gt_trm_termFlush(); + pTerm->SetCursorStyle( pTerm, iStyle ); + disp_mousecursor( pTerm ); + hb_gt_trm_termFlush( pTerm ); } -static BOOL hb_gt_trm_Info( int iType, PHB_GT_INFO pInfo ) +static BOOL hb_gt_trm_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) { + PHB_GTTRM pTerm; char * szVal; int iVal; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_Info(%d,%p)", iType, pInfo ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_trm_Info(%p,%d,%p)", pGT, iType, pInfo ) ); + pTerm = HB_GTTRM_GET( pGT ); switch( iType ) { case GTI_FULLSCREEN: @@ -3322,26 +3382,26 @@ static BOOL hb_gt_trm_Info( int iType, PHB_GT_INFO pInfo ) break; case GTI_ESCDELAY: - pInfo->pResult = hb_itemPutNI( pInfo->pResult, s_termState.esc_delay ); + pInfo->pResult = hb_itemPutNI( pInfo->pResult, pTerm->esc_delay ); if( hb_itemType( pInfo->pNewVal ) & HB_IT_NUMERIC ) - s_termState.esc_delay = hb_itemGetNI( pInfo->pNewVal ); + pTerm->esc_delay = hb_itemGetNI( pInfo->pNewVal ); break; case GTI_DELKEYMAP: szVal = hb_itemGetCPtr( pInfo->pNewVal ); if( szVal && *szVal ) - removeKeyMap( hb_itemGetCPtr( pInfo->pNewVal ) ); + removeKeyMap( pTerm, hb_itemGetCPtr( pInfo->pNewVal ) ); break; case GTI_ADDKEYMAP: iVal = hb_arrayGetNI( pInfo->pNewVal, 1 ); szVal = hb_arrayGetCPtr( pInfo->pNewVal, 2 ); if( iVal && szVal && *szVal ) - addKeyMap( SET_CLIPKEY( iVal ), szVal ); + addKeyMap( pTerm, SET_CLIPKEY( iVal ), szVal ); break; default: - return HB_GTSUPER_INFO( iType, pInfo ); + return HB_GTSUPER_INFO( pGT, iType, pInfo ); } return TRUE; diff --git a/harbour/source/rtl/gtwin/gtwin.c b/harbour/source/rtl/gtwin/gtwin.c index 6b283cb9b2..9574852b48 100644 --- a/harbour/source/rtl/gtwin/gtwin.c +++ b/harbour/source/rtl/gtwin/gtwin.c @@ -546,31 +546,31 @@ static BOOL WINAPI hb_gt_win_CtrlHandler( DWORD dwCtrlType ) /* *********************************************************************** */ -static void hb_gt_win_xGetScreenContents( SMALL_RECT * psrWin ) +static void hb_gt_win_xGetScreenContents( PHB_GT pGT, SMALL_RECT * psrWin ) { int iRow, iCol, i; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_GetScreenContents()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_xGetScreenContents(%p,%p)", pGT, psrWin)); for( iRow = psrWin->Top; iRow <= psrWin->Bottom; ++iRow ) { i = iRow * _GetScreenWidth() + psrWin->Left; for( iCol = psrWin->Left; iCol <= psrWin->Right; ++iCol ) { - hb_gt_PutScrChar( iRow, iCol, ( BYTE ) s_pCharInfoScreen[i].Attributes, 0, - s_charTransRev[ ( BYTE ) s_pCharInfoScreen[i].Char.AsciiChar ] ); + HB_GTSELF_PUTSCRCHAR( pGT, iRow, iCol, ( BYTE ) s_pCharInfoScreen[i].Attributes, 0, + s_charTransRev[ ( BYTE ) s_pCharInfoScreen[i].Char.AsciiChar ] ); ++i; } } - hb_gt_ColdArea( psrWin->Top, psrWin->Left, psrWin->Bottom, psrWin->Right ); + HB_GTSELF_COLDAREA( pGT, psrWin->Top, psrWin->Left, psrWin->Bottom, psrWin->Right ); } /* *********************************************************************** */ -static void hb_gt_win_xInitScreenParam( void ) +static void hb_gt_win_xInitScreenParam( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_xInitScreenParam()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_xInitScreenParam(%p)", pGT)); if( GetConsoleScreenBufferInfo( s_HOutput, &s_csbi ) ) { @@ -579,7 +579,7 @@ static void hb_gt_win_xInitScreenParam( void ) ULONG ulSize = ( ULONG ) _GetScreenWidth() * _GetScreenHeight() * sizeof( CHAR_INFO ); - HB_GTSUPER_RESIZE( _GetScreenHeight(), _GetScreenWidth() ); + HB_GTSUPER_RESIZE( pGT, _GetScreenHeight(), _GetScreenWidth() ); if( s_pCharInfoScreen == NULL || ulSize != s_ulScreenBuffSize ) { @@ -617,15 +617,15 @@ static void hb_gt_win_xInitScreenParam( void ) coDest.X = srWin.Left; /* read the screen rectangle into the buffer */ - if ( ReadConsoleOutput( s_HOutput, /* screen handle */ - s_pCharInfoScreen, /* transfer area */ - s_csbi.dwSize, /* size of destination buffer */ - coDest, /* upper-left cell to write data to */ - &srWin ) ) /* screen buffer rectangle to read from */ + if( ReadConsoleOutput( s_HOutput, /* screen handle */ + s_pCharInfoScreen, /* transfer area */ + s_csbi.dwSize, /* size of destination buffer */ + coDest, /* upper-left cell to write data to */ + &srWin ) ) /* screen buffer rectangle to read from */ { - hb_gt_win_xGetScreenContents( &srWin ); + hb_gt_win_xGetScreenContents( pGT, &srWin ); } - hb_gt_SetPos( s_sCurRow, s_sCurCol ); + HB_GTSELF_SETPOS( pGT, s_sCurRow, s_sCurCol ); } else if( s_pCharInfoScreen != NULL ) { @@ -636,9 +636,9 @@ static void hb_gt_win_xInitScreenParam( void ) /* *********************************************************************** */ -static void hb_gt_win_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) +static void hb_gt_win_Init( PHB_GT pGT, FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_Init(%p,%p,%p)", hFilenoStdin, hFilenoStdout, hFilenoStderr)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_Init(%p,%p,%p,%p)", pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr)); s_osv.dwOSVersionInfoSize = sizeof( OSVERSIONINFO ); GetVersionEx( &s_osv ); @@ -665,8 +665,8 @@ static void hb_gt_win_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE s_bAltKeyHandling = TRUE; /* initialize code page translation */ - hb_gt_SetDispCP( NULL, NULL, FALSE ); - hb_gt_SetKeyCP( NULL, NULL ); + HB_GTSELF_SETDISPCP( pGT, NULL, NULL, FALSE ); + HB_GTSELF_SETKEYCP( pGT, NULL, NULL ); /* Add Ctrl+Break handler [vszakats] */ SetConsoleCtrlHandler( hb_gt_win_CtrlHandler, TRUE ); @@ -711,7 +711,7 @@ static void hb_gt_win_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE } } - HB_GTSUPER_INIT( hFilenoStdin, hFilenoStdout, hFilenoStderr ); + HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr ); s_HOutput = CreateFile( TEXT( "CONOUT$" ), /* filename */ GENERIC_READ | GENERIC_WRITE, /* Access flag */ @@ -745,7 +745,7 @@ static void hb_gt_win_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE SetConsoleWindowInfo( s_HOutput, TRUE, &s_csbi.srWindow ); SetConsoleScreenBufferSize( s_HOutput, s_csbi.dwSize ); - hb_gt_win_xInitScreenParam(); + hb_gt_win_xInitScreenParam( pGT ); GetConsoleMode( s_HOutput, &s_dwomode ); GetConsoleMode( s_HInput, &s_dwimode ); @@ -755,11 +755,11 @@ static void hb_gt_win_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE /* *********************************************************************** */ -static void hb_gt_win_Exit( void ) +static void hb_gt_win_Exit( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_Exit()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_Exit(%p)", pGT)); - hb_gt_Refresh(); + HB_GTSELF_REFRESH( pGT ); if( s_pCharInfoScreen != NULL ) { @@ -782,16 +782,16 @@ static void hb_gt_win_Exit( void ) /* Remove Ctrl+Break handler */ SetConsoleCtrlHandler( hb_gt_win_CtrlHandler, FALSE ); - HB_GTSUPER_EXIT(); + HB_GTSUPER_EXIT( pGT ); } /* *********************************************************************** */ -static BOOL hb_gt_win_SetMode( int iRows, int iCols ) +static BOOL hb_gt_win_SetMode( PHB_GT pGT, int iRows, int iCols ) { BOOL fRet = FALSE; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_SetMode(%d, %d)", iRows, iCols)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_SetMode(%p,%d,%d)", pGT, iRows, iCols)); if( s_HOutput != INVALID_HANDLE_VALUE && iRows > 0 && iCols > 0 ) { @@ -819,7 +819,7 @@ static BOOL hb_gt_win_SetMode( int iRows, int iCols ) /* console window first, then the buffer */ if( ( DWORD ) _GetScreenWidth() * _GetScreenHeight() > ( DWORD ) iCols * iRows ) { - if ( SetConsoleWindowInfo( s_HOutput, TRUE, &srWin ) ) + if( SetConsoleWindowInfo( s_HOutput, TRUE, &srWin ) ) { SetConsoleScreenBufferSize( s_HOutput, coBuf ); fRet = TRUE; @@ -827,7 +827,7 @@ static BOOL hb_gt_win_SetMode( int iRows, int iCols ) } else { - if ( SetConsoleScreenBufferSize( s_HOutput, coBuf ) ) + if( SetConsoleScreenBufferSize( s_HOutput, coBuf ) ) { SetConsoleWindowInfo( s_HOutput, TRUE, &srWin ); fRet = TRUE; @@ -835,7 +835,7 @@ static BOOL hb_gt_win_SetMode( int iRows, int iCols ) } if( fRet ) - hb_gt_win_xInitScreenParam(); + hb_gt_win_xInitScreenParam( pGT ); } return fRet; @@ -843,11 +843,13 @@ static BOOL hb_gt_win_SetMode( int iRows, int iCols ) /* *********************************************************************** */ -static char * hb_gt_win_Version( int iType ) +static char * hb_gt_win_Version( PHB_GT pGT, int iType ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_win_Version(%d)", iType ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_win_Version(%p,%d)", pGT, iType ) ); - if ( iType == 0 ) + HB_SYMBOL_UNUSED( pGT ); + + if( iType == 0 ) return HB_GT_DRVNAME( HB_GT_NAME ); return "Harbour Terminal: Win32 buffered console"; @@ -855,28 +857,23 @@ static char * hb_gt_win_Version( int iType ) /* *********************************************************************** */ -static BOOL hb_gt_win_PreExt( void ) +static BOOL hb_gt_win_PostExt( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_PreExt()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_PostExt(%p)", pGT)); - return HB_GTSUPER_PREEXT(); -} - -static BOOL hb_gt_win_PostExt( void ) -{ - HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_PostExt()")); - - HB_GTSUPER_POSTEXT(); + HB_GTSUPER_POSTEXT( pGT ); if( s_pCharInfoScreen ) - hb_gt_win_xInitScreenParam(); + hb_gt_win_xInitScreenParam( pGT ); return TRUE; } /* *********************************************************************** */ -static BOOL hb_gt_win_Suspend( void ) +static BOOL hb_gt_win_Suspend( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_Suspend()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_Suspend(%p)", pGT)); + + HB_SYMBOL_UNUSED( pGT ); if( s_pCharInfoScreen ) { @@ -888,9 +885,9 @@ static BOOL hb_gt_win_Suspend( void ) return TRUE; } -static BOOL hb_gt_win_Resume( void ) +static BOOL hb_gt_win_Resume( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_Resume()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_Resume(%p)", pGT)); if( s_pCharInfoScreen ) { @@ -898,7 +895,7 @@ static BOOL hb_gt_win_Resume( void ) SetConsoleCtrlHandler( hb_gt_win_CtrlHandler, TRUE ); SetConsoleMode( s_HOutput, s_dwomode ); SetConsoleMode( s_HInput, b_MouseEnable ? ENABLE_MOUSE_INPUT : 0x0000 ); - hb_gt_win_xInitScreenParam(); + hb_gt_win_xInitScreenParam( pGT ); hb_gt_win_xSetCursorStyle(); } return TRUE; @@ -948,8 +945,8 @@ static int Handle_Alt_Key( int * paltisdown, int * paltnum, unsigned short wKey, printf( " the state %ld ",s_irInBuf[ s_cNumIndex ].Event.KeyEvent.dwControlKeyState ); #endif - if ((s_irInBuf[ s_cNumIndex ].Event.KeyEvent.dwControlKeyState & - 0x04000000 )) + if( s_irInBuf[ s_cNumIndex ].Event.KeyEvent.dwControlKeyState & + 0x04000000 ) /* ... has been released after a numpad entry */ { ch = *paltnum & 0xff; @@ -988,7 +985,7 @@ static int SpecialHandling( WORD * wChar, unsigned short wKey, int ch, BOOL lRev { if( lReverse ) { - switch (wKey) + switch( wKey ) { case 2: /* 1 to 9 */ case 3: @@ -1056,7 +1053,7 @@ static int SpecialHandling( WORD * wChar, unsigned short wKey, int ch, BOOL lRev } else { - switch (wKey) + switch( wKey ) { case 2: /* 1 to 9 */ case 3: @@ -1125,13 +1122,15 @@ static int SpecialHandling( WORD * wChar, unsigned short wKey, int ch, BOOL lRev return ch; } -static int hb_gt_win_ReadKey( int iEventMask ) +static int hb_gt_win_ReadKey( PHB_GT pGT, int iEventMask ) { int ch = 0, extKey = -1; const ClipKeyCode *clipKey = NULL; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_ReadKey(%d)", iEventMask)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_ReadKey(%p,%d)", pGT, iEventMask)); + + HB_SYMBOL_UNUSED( pGT ); /* First check for Ctrl+Break, which is handled by gt/gtwin.c */ if( s_bBreak ) @@ -1158,7 +1157,7 @@ static int hb_gt_win_ReadKey( int iEventMask ) /* Set up to process the first input event */ s_cNumIndex = 0; - if ( s_irInBuf[ s_cNumIndex ].EventType == KEY_EVENT ) + if( s_irInBuf[ s_cNumIndex ].EventType == KEY_EVENT ) { unsigned short wKey = s_irInBuf[ s_cNumIndex ].Event.KeyEvent.wVirtualScanCode; @@ -1181,12 +1180,10 @@ static int hb_gt_win_ReadKey( int iEventMask ) } else { - if ( wKey == 0x38 && - s_irInBuf[ s_cNumIndex ].Event.KeyEvent.bKeyDown && - (s_irInBuf[ s_cNumIndex ].Event.KeyEvent.dwControlKeyState - & NUMLOCK_ON ) - & ( (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED ) | NUMLOCK_ON ) - & ~(LEFT_CTRL_PRESSED) ) + if( wKey == 0x38 && + s_irInBuf[ s_cNumIndex ].Event.KeyEvent.bKeyDown && + ( s_irInBuf[ s_cNumIndex ].Event.KeyEvent.dwControlKeyState + & NUMLOCK_ON ) ) { s_altisdown = 1; } @@ -1203,7 +1200,7 @@ static int hb_gt_win_ReadKey( int iEventMask ) printf( " event %ld ",s_irInBuf[ s_cNumIndex ].EventType ); #endif - if ( s_irInBuf[ s_cNumIndex ].EventType == KEY_EVENT ) + if( s_irInBuf[ s_cNumIndex ].EventType == KEY_EVENT ) { /* Only process key down events */ @@ -1238,19 +1235,19 @@ static int hb_gt_win_ReadKey( int iEventMask ) * */ - if ( s_bSpecialKeyHandling && - ( dwState & CAPSLOCK_ON ) && - s_osv.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS ) + if( s_bSpecialKeyHandling && + ( dwState & CAPSLOCK_ON ) && + s_osv.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS ) { ch = SpecialHandling( &wChar, wKey, ch, (dwState & SHIFT_PRESSED) ); } - if ( s_wRepeated == 0 ) + if( s_wRepeated == 0 ) { s_wRepeated = s_irInBuf[ s_cNumIndex ].Event.KeyEvent.wRepeatCount; } - if ( s_wRepeated > 0 ) /* Might not be redundant */ + if( s_wRepeated > 0 ) /* Might not be redundant */ { s_wRepeated--; } @@ -1258,59 +1255,59 @@ static int hb_gt_win_ReadKey( int iEventMask ) printf( "\n\nhb_gt_ReadKey(): dwState is %ld, wChar is %d, wKey is %d, ch is %d", dwState, wChar, wKey, ch ); #endif - if ( wChar == 8 ) // VK_BACK + if( wChar == 8 ) /* VK_BACK */ { extKey = EXKEY_BS; } - else if ( wChar == 9 ) // VK_TAB + else if( wChar == 9 ) /* VK_TAB */ { extKey = EXKEY_TAB; } - else if ( wChar == 13 ) // VK_RETURN + else if( wChar == 13 ) /* VK_RETURN */ { extKey = EXKEY_ENTER; } - else if ( wChar == 27 ) // VK_ESCAPE + else if( wChar == 27 ) /* VK_ESCAPE */ { extKey = EXKEY_ESC; } - else if ( wChar == 33 ) // VK_PRIOR + else if( wChar == 33 ) /* VK_PRIOR */ { extKey = EXKEY_PGUP; } - else if ( wChar == 34 ) // VK_NEXT + else if( wChar == 34 ) /* VK_NEXT */ { extKey = EXKEY_PGDN; } - else if ( wChar == 35 ) // VK_END + else if( wChar == 35 ) /* VK_END */ { extKey = EXKEY_END; } - else if ( wChar == 36 ) // VK_HOME + else if( wChar == 36 ) /* VK_HOME */ { extKey = EXKEY_HOME; } - else if ( wChar == 37 ) // VK_LEFT + else if( wChar == 37 ) /* VK_LEFT */ { extKey = EXKEY_LEFT; } - else if ( wChar == 38 ) // VK_UP + else if( wChar == 38 ) /* VK_UP */ { extKey = EXKEY_UP; } - else if ( wChar == 39 ) // VK_RIGHT + else if( wChar == 39 ) /* VK_RIGHT */ { extKey = EXKEY_RIGHT; } - else if ( wChar == 40 ) // VK_DOWN + else if( wChar == 40 ) /* VK_DOWN */ { extKey = EXKEY_DOWN; } - else if ( wChar == 45 ) // VK_INSERT + else if( wChar == 45 ) /* VK_INSERT */ { extKey = EXKEY_INS; } - else if ( wChar == 46 && (!(ch==46)) ) // VK_DELETE + else if( wChar == 46 && (!(ch==46)) ) /* VK_DELETE */ { /* International keyboard under Win98 - when VirtualKey and Ascii char are both 46, then it's keypad del key, but numlock is on, @@ -1318,52 +1315,52 @@ static int hb_gt_win_ReadKey( int iEventMask ) */ extKey = EXKEY_DEL; } - else if ( wChar == 191 && ch == 63 && ( dwState & ENHANCED_KEY )) + else if( wChar == 191 && ch == 63 && ( dwState & ENHANCED_KEY )) { /* numpad '/' always */ /* This is the Win98 test */ ch = 47; } - else if ( wChar == 106 ) // VK_MULTIPLY + else if( wChar == 106 ) /* VK_MULTIPLY */ { extKey = EXKEY_KPASTERISK; } - else if ( wChar == 107 ) // VK_ADD + else if( wChar == 107 ) /* VK_ADD */ { extKey = EXKEY_KPPLUS; } - else if ( wChar == 109 ) // VK_SUBTRACT + else if( wChar == 109 ) /* VK_SUBTRACT */ { extKey = EXKEY_KPMINUS; } - else if ( wChar == 111 || // VK_DIVIDE + else if( wChar == 111 || /* VK_DIVIDE */ ( wChar == 191 && ( dwState & ENHANCED_KEY ))) { /* This should be for other than Win98 */ extKey = EXKEY_KPDIVIDE; } - else if ( wChar >= 112 && wChar <= 123 ) // F1-F12 VK_F1-VK_F12 + else if( wChar >= 112 && wChar <= 123 ) /* F1-F12 VK_F1-VK_F12 */ { extKey = wChar - 112; } - else if ( ch >= K_SPACE && ch <= K_CTRL_BS ) + else if( ch >= K_SPACE && ch <= K_CTRL_BS ) { clipKey = &stdKeyTab[ ch - K_SPACE ]; } - else if ( ch > 0 && ch < K_SPACE && ( dwState & ( LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED ) ) ) + else if( ch > 0 && ch < K_SPACE && ( dwState & ( LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED ) ) ) { clipKey = &stdKeyTab[ ch + '@' ]; } - else if ( ch < 0 ) // international keys + else if( ch < 0 ) /* international keys */ { ch += 256; } - if ( extKey > -1 ) + if( extKey > -1 ) { clipKey = &extKeyTab[ extKey ]; } - if ( clipKey != NULL ) + if( clipKey != NULL ) { if( ( dwState & SHIFT_PRESSED ) && ( dwState & ( LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED ) ) ) { @@ -1393,7 +1390,7 @@ static int hb_gt_win_ReadKey( int iEventMask ) ch = clipKey->key; } - if( ch == 0 ) // for keys that are only on shift or AltGr + if( ch == 0 ) /* for keys that are only on shift or AltGr */ { ch = clipKey->key; } @@ -1467,13 +1464,13 @@ static int hb_gt_win_ReadKey( int iEventMask ) } /* Set up to process the next input event (if any) */ - if ( s_wRepeated == 0 ) + if( s_wRepeated == 0 ) { s_cNumIndex++; } } #if 0 - if (ch ) + if( ch ) { printf(" %ld:%ld",ch,extKey); } @@ -1486,22 +1483,24 @@ static int hb_gt_win_ReadKey( int iEventMask ) /* *********************************************************************** */ /* dDuration is in 'Ticks' (18.2 per second) */ -static void hb_gt_win_Tone( double dFrequency, double dDuration ) +static void hb_gt_win_Tone( PHB_GT pGT, double dFrequency, double dDuration ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_Tone(%lf, %lf)", dFrequency, dDuration)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_Tone(%p,%lf,%lf)", pGT, dFrequency, dDuration)); + + HB_SYMBOL_UNUSED( pGT ); hb_gt_w32_tone( dFrequency, dDuration ); } /* *********************************************************************** */ -static BOOL hb_gt_win_SetDispCP( char *pszTermCDP, char *pszHostCDP, BOOL fBox ) +static BOOL hb_gt_win_SetDispCP( PHB_GT pGT, char *pszTermCDP, char *pszHostCDP, BOOL fBox ) { int i; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_SetDispCP(%s,%s,%d)", pszTermCDP, pszHostCDP, (int) fBox)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_SetDispCP(%p,%s,%s,%d)", pGT, pszTermCDP, pszHostCDP, (int) fBox)); - HB_GTSUPER_SETDISPCP( pszTermCDP, pszHostCDP, fBox ); + HB_GTSUPER_SETDISPCP( pGT, pszTermCDP, pszHostCDP, fBox ); for( i = 0; i < 256; i++ ) s_charTrans[ i ] = ( BYTE ) i; @@ -1536,11 +1535,13 @@ static BOOL hb_gt_win_SetDispCP( char *pszTermCDP, char *pszHostCDP, BOOL fBox ) /* *********************************************************************** */ -static BOOL hb_gt_win_SetKeyCP( char *pszTermCDP, char *pszHostCDP ) +static BOOL hb_gt_win_SetKeyCP( PHB_GT pGT, char *pszTermCDP, char *pszHostCDP ) { int i; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_SetKeyCP(%s,%s)", pszTermCDP, pszHostCDP)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_win_SetKeyCP(%p,%s,%s)", pGT, pszTermCDP, pszHostCDP)); + + HB_GTSUPER_SETKEYCP( pGT, pszTermCDP, pszHostCDP ); for( i = 0; i < 256; i++ ) s_keyTrans[ i ] = ( BYTE ) i; @@ -1567,9 +1568,6 @@ static BOOL hb_gt_win_SetKeyCP( char *pszTermCDP, char *pszHostCDP ) } } } -#else - HB_SYMBOL_UNUSED( pszTermCDP ); - HB_SYMBOL_UNUSED( pszHostCDP ); #endif return TRUE; @@ -1577,11 +1575,11 @@ static BOOL hb_gt_win_SetKeyCP( char *pszTermCDP, char *pszHostCDP ) /* *********************************************************************** */ -static BOOL hb_gt_win_Info( int iType, PHB_GT_INFO pInfo ) +static BOOL hb_gt_win_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_win_Info(%d,%p)", iType, pInfo ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_win_Info(%p,%d,%p)", pGT, iType, pInfo ) ); - switch ( iType ) + switch( iType ) { case GTI_FULLSCREEN: case GTI_KBDSUPPORT: @@ -1670,7 +1668,7 @@ static BOOL hb_gt_win_Info( int iType, PHB_GT_INFO pInfo ) break; default: - return HB_GTSUPER_INFO( iType, pInfo ); + return HB_GTSUPER_INFO( pGT, iType, pInfo ); } return TRUE; @@ -1678,35 +1676,43 @@ static BOOL hb_gt_win_Info( int iType, PHB_GT_INFO pInfo ) /* *********************************************************************** */ -static BOOL hb_gt_win_mouse_IsPresent( void ) +static BOOL hb_gt_win_mouse_IsPresent( PHB_GT pGT ) { + HB_SYMBOL_UNUSED( pGT ); + return b_MouseEnable; } -static void hb_gt_win_mouse_GetPos( int * piRow, int * piCol ) +static void hb_gt_win_mouse_GetPos( PHB_GT pGT, int * piRow, int * piCol ) { + HB_SYMBOL_UNUSED( pGT ); + *piRow = hb_mouse_iRow; *piCol = hb_mouse_iCol; } -static BOOL hb_gt_win_mouse_ButtonState( int iButton ) +static BOOL hb_gt_win_mouse_ButtonState( PHB_GT pGT, int iButton ) { BOOL fReturn = FALSE; - if ( iButton == 0 ) + HB_SYMBOL_UNUSED( pGT ); + + if( iButton == 0 ) fReturn = ( GetKeyState( VK_LBUTTON ) & 0x8000 ) != 0; - else if ( iButton== 1 ) + else if( iButton== 1 ) fReturn = ( GetKeyState( VK_RBUTTON ) & 0x8000 ) != 0; - else if ( iButton == 2 ) + else if( iButton == 2 ) fReturn = ( GetKeyState( VK_MBUTTON ) & 0x8000 ) != 0; return fReturn; } -static int hb_gt_win_mouse_CountButton( void ) +static int hb_gt_win_mouse_CountButton( PHB_GT pGT ) { DWORD dwCount = 0; + HB_SYMBOL_UNUSED( pGT ); + GetNumberOfConsoleMouseButtons( &dwCount ); return ( int ) dwCount; @@ -1714,9 +1720,9 @@ static int hb_gt_win_mouse_CountButton( void ) /* *********************************************************************** */ -static void hb_gt_win_Redraw( int iRow, int iCol, int iSize ) +static void hb_gt_win_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_win_Redraw(%d, %d, %d)", iRow, iCol, iSize ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_win_Redraw(%p,%d,%d,%d)", pGT, iRow, iCol, iSize ) ); if( iSize > 0 && s_pCharInfoScreen != NULL && iRow < ( int ) _GetScreenHeight() && iCol < ( int ) _GetScreenWidth() ) @@ -1728,7 +1734,7 @@ static void hb_gt_win_Redraw( int iRow, int iCol, int iSize ) while( iSize-- > 0 ) { - if( !hb_gt_GetScrChar( iRow, iCol++, &bColor, &bAttr, &usChar ) ) + if( !HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol++, &bColor, &bAttr, &usChar ) ) break; s_pCharInfoScreen[i].Char.AsciiChar = ( CHAR ) s_charTrans[ usChar & 0xFF ]; s_pCharInfoScreen[i].Attributes = ( WORD ) ( bColor & 0xFF ); @@ -1741,17 +1747,17 @@ static void hb_gt_win_Redraw( int iRow, int iCol, int iSize ) /* *********************************************************************** */ -static void hb_gt_win_Refresh( void ) +static void hb_gt_win_Refresh( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_win_Refresh()") ); + HB_TRACE( HB_TR_DEBUG, ("hb_gt_win_Refresh(%p)", pGT) ); - HB_GTSUPER_REFRESH(); + HB_GTSUPER_REFRESH( pGT ); if( s_pCharInfoScreen ) { int iRow, iCol, iStyle; - hb_gt_GetScrCursor( &iRow, &iCol, &iStyle ); + HB_GTSELF_GETSCRCURSOR( pGT, &iRow, &iCol, &iStyle ); s_sCurRow = iRow; s_sCurCol = iCol; @@ -1783,7 +1789,6 @@ static BOOL hb_gt_FuncInit( PHB_GT_FUNCS pFuncTable ) pFuncTable->Redraw = hb_gt_win_Redraw; pFuncTable->Refresh = hb_gt_win_Refresh; pFuncTable->Version = hb_gt_win_Version; - pFuncTable->PreExt = hb_gt_win_PreExt; pFuncTable->PostExt = hb_gt_win_PostExt; pFuncTable->Suspend = hb_gt_win_Suspend; pFuncTable->Resume = hb_gt_win_Resume; diff --git a/harbour/source/rtl/gtwvt/gtwvt.c b/harbour/source/rtl/gtwvt/gtwvt.c index b82e1f9bea..f6435b61d8 100644 --- a/harbour/source/rtl/gtwvt/gtwvt.c +++ b/harbour/source/rtl/gtwvt/gtwvt.c @@ -97,9 +97,9 @@ static HANDLE s_hInstance; static HANDLE s_hPrevInstance; static int s_iCmdShow; -static GLOBAL_DATA _s; +static HB_GTWVT _s; -static COLORREF _COLORS[] = { +static const COLORREF _COLORS[16] = { BLACK, BLUE, GREEN, @@ -118,7 +118,7 @@ static COLORREF _COLORS[] = { BRIGHT_WHITE }; -static int K_Ctrl[] = +static const int K_Ctrl[] = { K_CTRL_A, K_CTRL_B, K_CTRL_C, K_CTRL_D, K_CTRL_E, K_CTRL_F, K_CTRL_G, K_CTRL_H, K_CTRL_I, K_CTRL_J, K_CTRL_K, K_CTRL_L, K_CTRL_M, K_CTRL_N, @@ -126,20 +126,21 @@ static int K_Ctrl[] = K_CTRL_V, K_CTRL_W, K_CTRL_X, K_CTRL_Y, K_CTRL_Z }; -static void hb_gt_wvt_InitStatics( void ) +static void hb_gt_wvt_InitStatics( PHB_GT pGT ) { OSVERSIONINFO osvi; osvi.dwOSVersionInfoSize = sizeof( OSVERSIONINFO ); GetVersionEx( &osvi ); + _s.pGT = pGT; _s.ROWS = WVT_DEFAULT_ROWS; _s.COLS = WVT_DEFAULT_COLS; _s.CaretExist = FALSE; _s.CaretHidden = FALSE; _s.CaretSize = 4; - _s.mousePos.x = 0; - _s.mousePos.y = 0; + _s.MousePos.x = 0; + _s.MousePos.y = 0; _s.MouseMove = TRUE; _s.hWnd = NULL; _s.keyPointerIn = 0; @@ -166,7 +167,7 @@ static void hb_gt_wvt_InitStatics( void ) static BOOL hb_gt_wvt_SetWindowSize( int iRow, int iCol ) { - if( HB_GTSUPER_RESIZE( iRow, iCol ) ) + if( HB_GTSUPER_RESIZE( _s.pGT, iRow, iCol ) ) { _s.ROWS = ( USHORT ) iRow; _s.COLS = ( USHORT ) iCol; @@ -447,8 +448,8 @@ static int hb_gt_wvt_key_ansi_to_oem( int c ) static void hb_gt_wvt_SetMousePos( int iRow, int iCol ) { - _s.mousePos.y = ( SHORT ) iRow; - _s.mousePos.x = ( SHORT ) iCol; + _s.MousePos.y = ( SHORT ) iRow; + _s.MousePos.x = ( SHORT ) iCol; } static void hb_gt_wvt_MouseEvent( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam ) @@ -908,7 +909,7 @@ static void hb_gt_wvt_PaintText( HWND hWnd, RECT updateRect ) while( iCol <= rcRect.right ) { - if( !hb_gt_GetScrChar( iRow, iCol, &bColor, &bAttr, &usChar ) ) + if( !HB_GTSELF_GETSCRCHAR( _s.pGT, iRow, iCol, &bColor, &bAttr, &usChar ) ) break; #if defined(UNICODE) @@ -939,7 +940,7 @@ static void hb_gt_wvt_UpdateCaret( void ) { int iRow, iCol, iStyle, iCaretSize; - hb_gt_GetScrCursor( &iRow, &iCol, &iStyle ); + HB_GTSELF_GETSCRCURSOR( _s.pGT, &iRow, &iCol, &iStyle ); if( iRow < 0 || iCol < 0 || iRow >= _s.ROWS || iCol >= _s.COLS ) { @@ -1197,16 +1198,17 @@ static HWND hb_gt_wvt_CreateWindow( HINSTANCE hInstance, HINSTANCE hPrevInstance */ /* ********************************************************************** */ -static void hb_gt_wvt_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) +static void hb_gt_wvt_Init( PHB_GT pGT, FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Init(%p,%p,%p)", hFilenoStdin, hFilenoStdout, hFilenoStderr ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Init(%p,%p,%p,%p)", pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr ) ); if( ! hb_winmainArgGet( &s_hInstance, &s_hPrevInstance, &s_iCmdShow ) ) { hb_errInternal( 10001, "It's not a window GUI program.", "", "" ); } - hb_gt_wvt_InitStatics(); + hb_gt_wvt_InitStatics( pGT ); + HB_GTLOCAL( pGT ) = ( void * ) &_s; _s.hWnd = hb_gt_wvt_CreateWindow( ( HINSTANCE ) s_hInstance, ( HINSTANCE ) s_hPrevInstance, "", s_iCmdShow ); @@ -1229,18 +1231,18 @@ static void hb_gt_wvt_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE } /* SUPER GT initialization */ - HB_GTSUPER_INIT( hFilenoStdin, hFilenoStdout, hFilenoStderr ); - HB_GTSUPER_RESIZE( _s.ROWS, _s.COLS ); - HB_GTSUPER_EXPOSEAREA( 0, 0, _s.ROWS, _s.COLS ); + HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr ); + HB_GTSUPER_RESIZE( pGT, _s.ROWS, _s.COLS ); + HB_GTSUPER_EXPOSEAREA( pGT, 0, 0, _s.ROWS, _s.COLS ); } /* ********************************************************************** */ -static void hb_gt_wvt_Exit( void ) +static void hb_gt_wvt_Exit( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_wvt_Exit()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_wvt_Exit(%p)", pGT)); - HB_GTSUPER_EXIT(); + HB_GTSUPER_EXIT( pGT ); if( _s.hWnd ) { @@ -1252,11 +1254,13 @@ static void hb_gt_wvt_Exit( void ) /* ********************************************************************** */ -static BOOL hb_gt_wvt_SetMode( int iRow, int iCol ) +static BOOL hb_gt_wvt_SetMode( PHB_GT pGT, int iRow, int iCol ) { BOOL fResult = FALSE; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_SetMode( %hu, %hu )", iRow, iCol ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_SetMode(%p,%d,%d)", pGT, iRow, iCol ) ); + + HB_SYMBOL_UNUSED( pGT ); if( iRow <= WVT_MAX_ROWS && iCol <= WVT_MAX_COLS ) { @@ -1289,9 +1293,11 @@ static BOOL hb_gt_wvt_SetMode( int iRow, int iCol ) /* ********************************************************************** */ -static char * hb_gt_wvt_Version( int iType ) +static char * hb_gt_wvt_Version( PHB_GT pGT, int iType ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Version()" ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Version(%p,%d)", pGT, iType ) ); + + HB_SYMBOL_UNUSED( pGT ); if( iType == 0 ) return HB_GT_DRVNAME( HB_GT_NAME ); @@ -1301,13 +1307,14 @@ static char * hb_gt_wvt_Version( int iType ) /* ********************************************************************** */ -static int hb_gt_wvt_ReadKey( int iEventMask ) +static int hb_gt_wvt_ReadKey( PHB_GT pGT, int iEventMask ) { int c = 0; BOOL fKey; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_ReadKey( %d )", iEventMask ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_ReadKey(%p,%d)", pGT, iEventMask ) ); + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( iEventMask ); /* we ignore the eventmask! */ hb_gt_wvt_ProcessMessages(); @@ -1318,33 +1325,41 @@ static int hb_gt_wvt_ReadKey( int iEventMask ) /* ********************************************************************** */ /* dDuration is in 'Ticks' (18.2 per second) */ -static void hb_gt_wvt_Tone( double dFrequency, double dDuration ) +static void hb_gt_wvt_Tone( PHB_GT pGT, double dFrequency, double dDuration ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_wvt_Tone(%lf, %lf)", dFrequency, dDuration)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_wvt_Tone(%p,%lf,%lf)", pGT, dFrequency, dDuration)); + + HB_SYMBOL_UNUSED( pGT ); hb_gt_w32_tone( dFrequency, dDuration ); } /* ********************************************************************** */ -static BOOL hb_gt_wvt_mouse_IsPresent( void ) +static BOOL hb_gt_wvt_mouse_IsPresent( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_wvt_mouse_IsPresent()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_wvt_mouse_IsPresent(%p)", pGT)); + + HB_SYMBOL_UNUSED( pGT ); return TRUE; } -static void hb_gt_wvt_mouse_GetPos( int * piRow, int * piCol ) +static void hb_gt_wvt_mouse_GetPos( PHB_GT pGT, int * piRow, int * piCol ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_wvt_mouse_GetPos(%p,%p)", piRow, piCol)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_wvt_mouse_GetPos(%p,%p,%p)", pGT, piRow, piCol)); - *piRow = _s.mousePos.y; - *piCol = _s.mousePos.x; + HB_SYMBOL_UNUSED( pGT ); + + *piRow = _s.MousePos.y; + *piCol = _s.MousePos.x; } -static BOOL hb_gt_wvt_mouse_ButtonState( int iButton ) +static BOOL hb_gt_wvt_mouse_ButtonState( PHB_GT pGT, int iButton ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_mouse_ButtonState(%i)", iButton ) ); + HB_TRACE( HB_TR_DEBUG, ("hb_gt_wvt_mouse_ButtonState(%p,%i)", pGT, iButton) ); + + HB_SYMBOL_UNUSED( pGT ); switch( iButton ) { @@ -1358,20 +1373,22 @@ static BOOL hb_gt_wvt_mouse_ButtonState( int iButton ) return FALSE; } -static int hb_gt_wvt_mouse_CountButton( void ) +static int hb_gt_wvt_mouse_CountButton( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_mouse_CountButton()") ); + HB_TRACE( HB_TR_DEBUG, ("hb_gt_wvt_mouse_CountButton(%p)", pGT) ); + + HB_SYMBOL_UNUSED( pGT ); return GetSystemMetrics( SM_CMOUSEBUTTONS ); } /* ********************************************************************** */ -static BOOL hb_gt_wvt_Info( int iType, PHB_GT_INFO pInfo ) +static BOOL hb_gt_wvt_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) { int iVal; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Info(%d,%p)", iType, pInfo ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Info(%p,%d,%p)", pGT, iType, pInfo ) ); switch( iType ) { @@ -1519,7 +1536,7 @@ static BOOL hb_gt_wvt_Info( int iType, PHB_GT_INFO pInfo ) iVal = hb_itemGetNI( pInfo->pNewVal ); if( iVal > 0 ) { - hb_gtSetMode( (USHORT) ( iVal / _s.PTEXTSIZE.y ), _s.COLS ); + HB_GTSELF_SETMODE( pGT, (USHORT) ( iVal / _s.PTEXTSIZE.y ), _s.COLS ); } break; @@ -1528,7 +1545,7 @@ static BOOL hb_gt_wvt_Info( int iType, PHB_GT_INFO pInfo ) iVal = hb_itemGetNI( pInfo->pNewVal ); if( iVal > 0 ) { - hb_gtSetMode( _s.ROWS, (USHORT) ( iVal / _s.PTEXTSIZE.x ) ); + HB_GTSELF_SETMODE( pGT, _s.ROWS, (USHORT) ( iVal / _s.PTEXTSIZE.x ) ); } break; @@ -1681,7 +1698,7 @@ static BOOL hb_gt_wvt_Info( int iType, PHB_GT_INFO pInfo ) break; default: - return HB_GTSUPER_INFO( iType, pInfo ); + return HB_GTSUPER_INFO( pGT, iType, pInfo ); } return TRUE; @@ -1717,14 +1734,16 @@ static BOOL hb_gt_wvt_Info( int iType, PHB_GT_INFO pInfo ) ReleaseDC( _s.hWnd, hdc ); \ } while( 0 ) -static int hb_gt_wvt_gfx_Primitive( int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor ) +static int hb_gt_wvt_gfx_Primitive( PHB_GT pGT, int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor ) { HDC hdc; HPEN hPen, hOldPen; HBRUSH hBrush, hOldBrush; int iRet = 0; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_gfx_Primitive(%d, %d, %d, %d, %d, %d)", iType, iTop, iLeft, iBottom, iRight, iColor ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_gfx_Primitive(%p,%d,%d,%d,%d,%d,%d)", pGT, iType, iTop, iLeft, iBottom, iRight, iColor ) ); + + HB_SYMBOL_UNUSED( pGT ); if( _s.hWnd ) { @@ -1836,8 +1855,9 @@ static int hb_gt_wvt_gfx_Primitive( int iType, int iTop, int iLeft, int iBottom, } /* -static void hb_gt_wvt_gfx_Text( int iTop, int iLeft, char *cBuf, int iColor, int iSize, int iWidth ) +static void hb_gt_wvt_gfx_Text( PHB_GT pGT, int iTop, int iLeft, char *cBuf, int iColor, int iSize, int iWidth ) { + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( iTop ); HB_SYMBOL_UNUSED( iLeft ); HB_SYMBOL_UNUSED( cBuf ); @@ -1849,9 +1869,11 @@ static void hb_gt_wvt_gfx_Text( int iTop, int iLeft, char *cBuf, int iColor, int /* ********************************************************************** */ -static void hb_gt_wvt_Redraw( int iRow, int iCol, int iSize ) +static void hb_gt_wvt_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Redraw(%d, %d, %d)", iRow, iCol, iSize ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Redraw(%p,%d,%d,%d)", pGT, iRow, iCol, iSize ) ); + + HB_SYMBOL_UNUSED( pGT ); if( _s.hWnd ) { @@ -1869,11 +1891,11 @@ static void hb_gt_wvt_Redraw( int iRow, int iCol, int iSize ) /* ********************************************************************** */ -static void hb_gt_wvt_Refresh( void ) +static void hb_gt_wvt_Refresh( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_wvt_Refresh()") ); + HB_TRACE( HB_TR_DEBUG, ("hb_gt_wvt_Refresh(%p)", pGT) ); - HB_GTSUPER_REFRESH(); + HB_GTSUPER_REFRESH( pGT ); if( _s.hWnd ) { @@ -1884,10 +1906,9 @@ static void hb_gt_wvt_Refresh( void ) /* ********************************************************************** */ -static BOOL hb_gt_wvt_SetDispCP( char * pszTermCDP, char * pszHostCDP, BOOL fBox ) +static BOOL hb_gt_wvt_SetDispCP( PHB_GT pGT, char * pszTermCDP, char * pszHostCDP, BOOL fBox ) { - - HB_GTSUPER_SETDISPCP( pszTermCDP, pszHostCDP, fBox ); + HB_GTSUPER_SETDISPCP( pGT, pszTermCDP, pszHostCDP, fBox ); #ifndef HB_CDP_SUPPORT_OFF /* @@ -1913,9 +1934,9 @@ static BOOL hb_gt_wvt_SetDispCP( char * pszTermCDP, char * pszHostCDP, BOOL fBox return TRUE; } -static BOOL hb_gt_wvt_SetKeyCP( char * pszTermCDP, char * pszHostCDP ) +static BOOL hb_gt_wvt_SetKeyCP( PHB_GT pGT, char * pszTermCDP, char * pszHostCDP ) { - HB_GTSUPER_SETKEYCP( pszTermCDP, pszHostCDP ); + HB_GTSUPER_SETKEYCP( pGT, pszTermCDP, pszHostCDP ); #ifndef HB_CDP_SUPPORT_OFF /* diff --git a/harbour/source/rtl/gtwvt/gtwvt.h b/harbour/source/rtl/gtwvt/gtwvt.h index 0da1566be8..dd2443037f 100644 --- a/harbour/source/rtl/gtwvt/gtwvt.h +++ b/harbour/source/rtl/gtwvt/gtwvt.h @@ -109,8 +109,10 @@ #define WM_MY_UPDATE_CARET ( WM_USER + 0x0101 ) -typedef struct global_data +typedef struct { + PHB_GT pGT; /* core GT pointer */ + USHORT ROWS; /* number of displayable rows in window */ USHORT COLS; /* number of displayable columns in window */ @@ -118,7 +120,7 @@ typedef struct global_data BOOL CaretHidden; /* TRUE if a caret has been hiden */ int CaretSize; /* Size of solid caret */ - POINT mousePos; /* the last mouse position */ + POINT MousePos; /* the last mouse position */ BOOL MouseMove; /* Flag to say whether to return mouse movement events */ int Keys[ WVT_CHAR_QUEUE_SIZE ]; /* Array to hold the characters & events */ @@ -148,7 +150,7 @@ typedef struct global_data BOOL IgnoreWM_SYSCHAR; -} GLOBAL_DATA, * LPGLOBAL_DATA; +} HB_GTWVT, * PHB_GTWVT; /* xHarbour compatible definitions */ #if !defined( K_SH_LEFT ) diff --git a/harbour/source/rtl/gtxwc/gtxwc.c b/harbour/source/rtl/gtxwc/gtxwc.c index 8e3e39e6c2..3d9345c25f 100644 --- a/harbour/source/rtl/gtxwc/gtxwc.c +++ b/harbour/source/rtl/gtxwc/gtxwc.c @@ -62,10 +62,12 @@ static HB_GT_FUNCS SuperTable; #define HB_GTSUPER (&SuperTable) #define HB_GTID_PTR (&s_GtId) +#define HB_GTXWC_GET(p) ( ( PXWND_DEF ) HB_GTLOCAL( p ) ) + /* mouse button mapping into Clipper keycodes */ -static int mousePressKeys[ XWC_MAX_BUTTONS ] = { K_LBUTTONDOWN, K_MBUTTONDOWN, K_RBUTTONDOWN, K_MWFORWARD, K_MWBACKWARD }; -static int mouseReleaseKeys[ XWC_MAX_BUTTONS ] = { K_LBUTTONUP, K_MBUTTONUP, K_RBUTTONUP }; -static int mouseDblPressKeys[ XWC_MAX_BUTTONS ] = { K_LDBLCLK, K_MDBLCLK, K_RDBLCLK , K_MWFORWARD, K_MWBACKWARD }; +static const int mousePressKeys[ XWC_MAX_BUTTONS ] = { K_LBUTTONDOWN, K_MBUTTONDOWN, K_RBUTTONDOWN, K_MWFORWARD, K_MWBACKWARD }; +static const int mouseReleaseKeys[ XWC_MAX_BUTTONS ] = { K_LBUTTONUP, K_MBUTTONUP, K_RBUTTONUP }; +static const int mouseDblPressKeys[ XWC_MAX_BUTTONS ] = { K_LDBLCLK, K_MDBLCLK, K_RDBLCLK , K_MWFORWARD, K_MWBACKWARD }; typedef struct tag_ClipKeyCode { int key; @@ -322,6 +324,8 @@ typedef struct tag_modifiers typedef struct tag_x_wnddef { + PHB_GT pGT; + Display *dpy; Window window; GC gc; @@ -337,6 +341,9 @@ typedef struct tag_x_wnddef /* is anything written to screen */ BOOL fData; + /* block recursive refresh calls */ + BOOL fRefresh; + /* window size in character cells */ USHORT cols; USHORT rows; @@ -387,6 +394,10 @@ typedef struct tag_x_wnddef int lastCursorRow; int lastCursorType; + BOOL cursorState; + ULONG cursorBlinkRate; + ULONG cursorStateTime; + /* Mouse informations */ int mouseCol; int mouseRow; @@ -441,10 +452,6 @@ static void hb_gt_xwc_InvalidatePts( PXWND_DEF wnd, int left, int top, int right static PXWND_DEF s_wnd = NULL; static BOOL s_fNoXServer = FALSE; -static BOOL s_cursorState = TRUE; -static ULONG s_cursorBlinkRate = 350; -static ULONG s_cursorStateTime = 0; - #if 1 static int s_updateMode = XWC_SYNC_UPDATE; #else @@ -471,13 +478,15 @@ static int s_errorHandler( Display *dpy, XErrorEvent *e ) static void hb_gt_xwc_SigHandler( int iSig ) { + PXWND_DEF wnd = s_wnd; + HB_SYMBOL_UNUSED( iSig ); - if( s_updateMode == XWC_ASYNC_UPDATE && s_wnd && s_wnd->fInit ) + if( s_updateMode == XWC_ASYNC_UPDATE && wnd && wnd->fInit ) { if( s_iUpdateCounter ) --s_iUpdateCounter; - hb_gt_xwc_ProcessMessages( s_wnd ); + hb_gt_xwc_ProcessMessages( wnd ); } } @@ -2038,7 +2047,7 @@ static void hb_gt_xwc_WndProc( PXWND_DEF wnd, XEvent *evt ) { Time evtTime = ((XButtonEvent *) evt)->time; if( evtTime - wnd->mouseButtonsTime[ button ] < - ( Time ) hb_mouse_GetDoubleClickSpeed() ) + ( Time ) HB_GTSELF_MOUSEGETDOUBLECLICKSPEED( wnd->pGT ) ) { key = mouseDblPressKeys[ button ]; } @@ -2478,7 +2487,7 @@ static void hb_gt_xwc_RepaintChar( PXWND_DEF wnd, int colStart, int rowStart, in */ while( icol <= colStop ) { - hb_gt_GetScrChar( irow, icol, &color, &attr, &usCh16 ); + HB_GTSELF_GETSCRCHAR( wnd->pGT, irow, icol, &color, &attr, &usCh16 ); ulCurr = hb_gt_xwc_HashCurrChar( attr, color, usCh16 ); if( wnd->charTrans[ usCh16 ].inverse ) { @@ -2689,7 +2698,7 @@ static void hb_gt_xwc_InvalidatePts( PXWND_DEF wnd, static void hb_gt_xwc_UpdateCursor( PXWND_DEF wnd ) { - int cursorType = s_cursorState ? wnd->cursorType : SC_NONE; + int cursorType = wnd->cursorState ? wnd->cursorType : SC_NONE; /* must the mouse cursor be positioned? */ if( wnd->mouseGotoRow >= 0 && wnd->mouseGotoCol >= 0 ) @@ -2743,7 +2752,7 @@ static void hb_gt_xwc_UpdateCursor( PXWND_DEF wnd ) BYTE color, attr; USHORT usChar; - hb_gt_GetScrChar( wnd->row, wnd->col, &color, &attr, &usChar ); + HB_GTSELF_GETSCRCHAR( wnd->pGT, wnd->row, wnd->col, &color, &attr, &usChar ); XSetForeground( wnd->dpy, wnd->gc, wnd->pixels[color & 0x0f] ); XFillRectangle( wnd->dpy, wnd->window, wnd->gc, basex, basey, wnd->fontWidth, size ); @@ -2816,8 +2825,8 @@ static void hb_gt_xwc_UpdateSize( PXWND_DEF wnd ) if( wnd->fWinResize ) { wnd->fWinResize = FALSE; - hb_gtSetMode( wnd->newHeight / wnd->fontHeight, - wnd->newWidth / wnd->fontWidth ); + HB_GTSELF_SETMODE( wnd->pGT, wnd->newHeight / wnd->fontHeight, + wnd->newWidth / wnd->fontWidth ); } } @@ -2838,18 +2847,18 @@ static void hb_gt_xwc_ProcessMessages( PXWND_DEF wnd ) if( wnd->cursorType != SC_NONE ) { - if( s_cursorBlinkRate == 0 ) + if( wnd->cursorBlinkRate == 0 ) { - s_cursorState = TRUE; + wnd->cursorState = TRUE; } else { ULONG ulCurrentTime = hb_gt_xwc_CurrentTime(); - if( ulCurrentTime - s_cursorStateTime > s_cursorBlinkRate ) + if( ulCurrentTime - wnd->cursorStateTime > wnd->cursorBlinkRate ) { - s_cursorState = !s_cursorState; - s_cursorStateTime = ulCurrentTime; + wnd->cursorState = !wnd->cursorState; + wnd->cursorStateTime = ulCurrentTime; } } } @@ -2894,7 +2903,7 @@ static void hb_gt_xwc_SetScrBuff( PXWND_DEF wnd, USHORT cols, USHORT rows ) memset( wnd->pCurrScr, 0xFFFFFFFFL, iSize * sizeof( ULONG ) ); hb_gt_xwc_InvalidateChar( wnd, 0, 0, wnd->cols - 1, wnd->rows - 1 ); - HB_GTSUPER_RESIZE( wnd->rows, wnd->cols ); + HB_GTSUPER_RESIZE( wnd->pGT, wnd->rows, wnd->cols ); } } @@ -2965,7 +2974,7 @@ static BOOL hb_gt_xwc_SetFont( PXWND_DEF wnd, char *fontFace, char *weight, int /* *********************************************************************** */ -static PXWND_DEF hb_gt_xwc_CreateWndDef( void ) +static PXWND_DEF hb_gt_xwc_CreateWndDef( PHB_GT pGT ) { PHB_FNAME pFileName; PXWND_DEF wnd = ( PXWND_DEF ) hb_xgrab( sizeof( XWND_DEF ) ); @@ -2973,6 +2982,7 @@ static PXWND_DEF hb_gt_xwc_CreateWndDef( void ) /* clear whole structure */ memset( wnd, 0, sizeof( XWND_DEF ) ); + wnd->pGT = pGT; wnd->dpy = NULL; wnd->fInit = wnd->fData = FALSE; hb_gt_xwc_SetScrBuff( wnd, XWC_DEFAULT_COLS, XWC_DEFAULT_ROWS ); @@ -3228,7 +3238,7 @@ static void hb_gt_xwc_SetSelection( PXWND_DEF wnd, char *szData, ULONG ulSize ) else { char * cMsg = "Cannot set primary selection\r\n"; - hb_gt_OutErr( ( BYTE * ) cMsg, strlen( cMsg ) ); + HB_GTSELF_OUTERR( wnd->pGT, ( BYTE * ) cMsg, strlen( cMsg ) ); } } } @@ -3297,93 +3307,106 @@ static void hb_gt_xwc_RequestSelection( PXWND_DEF wnd ) /* *********************************************************************** */ -static void hb_gt_xwc_RealRefresh( void ) +static void hb_gt_xwc_RealRefresh( PXWND_DEF wnd ) { - static BOOL s_fRefresh = FALSE; + hb_gt_xwc_Initialize( wnd ); - hb_gt_xwc_Initialize( s_wnd ); - - if( s_updateMode == XWC_SYNC_UPDATE && !s_fRefresh ) + if( s_updateMode == XWC_SYNC_UPDATE && !wnd->fRefresh ) { - s_fRefresh = TRUE; - hb_gt_xwc_ProcessMessages( s_wnd ); - s_fRefresh = FALSE; + wnd->fRefresh = TRUE; + hb_gt_xwc_ProcessMessages( wnd ); + wnd->fRefresh = FALSE; } } /* *********************************************************************** */ -static void hb_gt_xwc_LateRefresh( void ) +static void hb_gt_xwc_LateRefresh( PXWND_DEF wnd ) { - if( s_wnd->fInit ) - hb_gt_xwc_RealRefresh(); + if( wnd->fInit ) + hb_gt_xwc_RealRefresh( wnd ); } /* *********************************************************************** */ /* *********************************************************************** */ -static void hb_gt_xwc_Init( FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) +static void hb_gt_xwc_Init( PHB_GT pGT, FHANDLE hFilenoStdin, FHANDLE hFilenoStdout, FHANDLE hFilenoStderr ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_Init(%p,%p,%p)", hFilenoStdin, hFilenoStdout, hFilenoStderr)); + PXWND_DEF wnd; - s_wnd = hb_gt_xwc_CreateWndDef(); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_Init(%p,%p,%p,%p)", pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr)); - HB_GTSUPER_INIT( hFilenoStdin, hFilenoStdout, hFilenoStderr ); - HB_GTSUPER_RESIZE( s_wnd->rows, s_wnd->cols ); - hb_gt_SemiCold(); + HB_GTSUPER_INIT( pGT, hFilenoStdin, hFilenoStdout, hFilenoStderr ); + + wnd = hb_gt_xwc_CreateWndDef( pGT ); + HB_GTLOCAL( pGT ) = wnd; + + /* for signal handler */ + s_wnd = wnd; + + wnd->cursorState = TRUE; + wnd->cursorBlinkRate = 350; + wnd->cursorStateTime = 0; + + HB_GTSUPER_RESIZE( pGT, wnd->rows, wnd->cols ); + HB_GTSELF_SEMICOLD( pGT ); /* For immediate connection to XSarver and screen Window show */ - /* hb_gt_xwc_Initialize( s_wnd ); */ + /* hb_gt_xwc_Initialize( wnd ); */ /* For connection to XSarver only */ - /* hb_gt_xwc_ConnectX( s_wnd, TRUE ); */ + /* hb_gt_xwc_ConnectX( wnd, TRUE ); */ } /* *********************************************************************** */ -static void hb_gt_xwc_Exit( void ) +static void hb_gt_xwc_Exit( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_Exit()")); + PXWND_DEF wnd; + + HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_Exit(%p)", pGT)); + + wnd = HB_GTXWC_GET( pGT ); hb_gt_xwc_Disable(); + HB_GTSUPER_EXIT( pGT ); - HB_GTSUPER_EXIT(); - - if( s_wnd ) + if( wnd ) { - hb_gt_xwc_DestroyWndDef( s_wnd ); - s_wnd = NULL; + hb_gt_xwc_DestroyWndDef( wnd ); } } /* *********************************************************************** */ -static BOOL hb_gt_xwc_SetMode( int iRow, int iCol ) +static BOOL hb_gt_xwc_SetMode( PHB_GT pGT, int iRow, int iCol ) { BOOL fResult = FALSE; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_SetMode(%d, %d)", iRow, iCol)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_SetMode(%p,%d,%d)", pGT, iRow, iCol)); if( iCol >= XWC_MIN_COLS && iRow >= XWC_MIN_ROWS && iCol <= XWC_MAX_COLS && iRow <= XWC_MAX_ROWS ) { - if( iCol == s_wnd->cols && iRow == s_wnd->rows ) + PXWND_DEF wnd = HB_GTXWC_GET( pGT ); + + if( iCol == wnd->cols && iRow == wnd->rows ) { fResult = TRUE; - HB_GTSUPER_RESIZE( s_wnd->rows, s_wnd->cols ); + HB_GTSUPER_RESIZE( pGT, wnd->rows, wnd->cols ); } - else if( !s_wnd->fInit ) + else if( !wnd->fInit ) { - hb_gt_xwc_SetScrBuff( s_wnd, iCol, iRow ); + hb_gt_xwc_SetScrBuff( wnd, iCol, iRow ); fResult = TRUE; } else { hb_gt_xwc_Disable(); - fResult = hb_gt_xwc_Resize( s_wnd, iCol, iRow ); + fResult = hb_gt_xwc_Resize( wnd, iCol, iRow ); if( fResult ) - HB_GTSUPER_RESIZE( s_wnd->rows, s_wnd->cols ); + HB_GTSUPER_RESIZE( pGT, wnd->rows, wnd->cols ); hb_gt_xwc_Enable(); } } @@ -3393,17 +3416,21 @@ static BOOL hb_gt_xwc_SetMode( int iRow, int iCol ) /* *********************************************************************** */ -static BOOL hb_gt_xwc_GetBlink() +static BOOL hb_gt_xwc_GetBlink( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_GetBlink()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_GetBlink(%p)", pGT)); + + HB_SYMBOL_UNUSED( pGT ); return FALSE; } /* *********************************************************************** */ -static char * hb_gt_xwc_Version( int iType ) +static char * hb_gt_xwc_Version( PHB_GT pGT, int iType ) { + HB_SYMBOL_UNUSED( pGT ); + if( iType == 0 ) return HB_GT_DRVNAME( HB_GT_NAME ); @@ -3412,18 +3439,20 @@ static char * hb_gt_xwc_Version( int iType ) /* *********************************************************************** */ -static int hb_gt_xwc_ReadKey( int iEventMask ) +static int hb_gt_xwc_ReadKey( PHB_GT pGT, int iEventMask ) { + PXWND_DEF wnd; int c = 0; + HB_TRACE(HB_TR_DEBUG, ("hb_wxc_gt_ReadKey(%p,%d)", pGT, iEventMask)); + HB_SYMBOL_UNUSED( iEventMask ); - HB_TRACE(HB_TR_DEBUG, ("hb_wxc_gt_ReadKey(%d)", iEventMask)); + wnd = HB_GTXWC_GET( pGT ); + hb_gt_xwc_LateRefresh( wnd ); + /* hb_gt_xwc_RealRefresh( wnd ); */ - hb_gt_xwc_LateRefresh(); - /* hb_gt_xwc_RealRefresh(); */ - - if( hb_gt_xwc_GetCharFromInputQueue( s_wnd, &c ) ) + if( hb_gt_xwc_GetCharFromInputQueue( wnd, &c ) ) return c; else return 0; @@ -3432,86 +3461,104 @@ static int hb_gt_xwc_ReadKey( int iEventMask ) /* *********************************************************************** */ -static void hb_gt_xwc_Tone( double dFrequency, double dDuration ) +static void hb_gt_xwc_Tone( PHB_GT pGT, double dFrequency, double dDuration ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_Tone(%lf, %lf)", dFrequency, dDuration)); + PXWND_DEF wnd; + + HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_Tone(%p,%lf,%lf)", pGT, dFrequency, dDuration)); /* The conversion from Clipper (DOS) timer tick units to milliseconds is * 1000.0 / 18.2. */ dDuration /= 18.2; - if( s_wnd->dpy != NULL ) + wnd = HB_GTXWC_GET( pGT ); + if( wnd->dpy != NULL ) { XKeyboardControl XkbCtrl; XkbCtrl.bell_pitch = (int) dFrequency; XkbCtrl.bell_duration = (int) (dDuration * 1000); - XChangeKeyboardControl( s_wnd->dpy, KBBellPitch | KBBellDuration, &XkbCtrl ); - XBell( s_wnd->dpy, 0 ); + XChangeKeyboardControl( wnd->dpy, KBBellPitch | KBBellDuration, &XkbCtrl ); + XBell( wnd->dpy, 0 ); } hb_idleSleep( dDuration ); } /* *********************************************************************** */ -static BOOL hb_gt_xwc_mouse_IsPresent( void ) +static BOOL hb_gt_xwc_mouse_IsPresent( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_mouse_IsPresent()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_mouse_IsPresent(%p)", pGT)); - return s_wnd->mouseNumButtons > 0; + return HB_GTXWC_GET( pGT )->mouseNumButtons > 0; } /* *********************************************************************** */ -static void hb_gt_xwc_mouse_GetPos( int * piRow, int * piCol ) +static void hb_gt_xwc_mouse_GetPos( PHB_GT pGT, int * piRow, int * piCol ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_mouse_GetPos(%p,%p)", piRow, piCol)); + PXWND_DEF wnd; - hb_gt_xwc_LateRefresh(); - *piRow = s_wnd->mouseRow; - *piCol = s_wnd->mouseCol; + HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_mouse_GetPos(%p,%p,%p)", pGT, piRow, piCol)); + + wnd = HB_GTXWC_GET( pGT ); + if( wnd ) + { + hb_gt_xwc_LateRefresh( wnd ); + *piRow = wnd->mouseRow; + *piCol = wnd->mouseCol; + } } /* *********************************************************************** */ -static void hb_gt_xwc_mouse_SetPos( int iRow, int iCol ) +static void hb_gt_xwc_mouse_SetPos( PHB_GT pGT, int iRow, int iCol ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_mouse_SetPos(%d,%d)", iRow, iCol)); + PXWND_DEF wnd; - s_wnd->mouseGotoRow = iRow; - s_wnd->mouseGotoCol = iCol; - hb_gt_xwc_LateRefresh(); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_mouse_SetPos(%p,%d,%d)", pGT, iRow, iCol)); + + wnd = HB_GTXWC_GET( pGT ); + wnd->mouseGotoRow = iRow; + wnd->mouseGotoCol = iCol; + hb_gt_xwc_LateRefresh( wnd ); } /* *********************************************************************** */ -static BOOL hb_gt_xwc_mouse_ButtonState( int iButton ) +static BOOL hb_gt_xwc_mouse_ButtonState( PHB_GT pGT,int iButton ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_mouse_ButtonState(%i)", iButton)); + PXWND_DEF wnd; - if( iButton >= 0 && iButton < s_wnd->mouseNumButtons ) - return ( s_wnd->mouseButtonsState & 1 << iButton ) != 0; + HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_mouse_ButtonState(%p,%i)", pGT, iButton)); + + wnd = HB_GTXWC_GET( pGT ); + if( iButton >= 0 && iButton < wnd->mouseNumButtons ) + return ( wnd->mouseButtonsState & 1 << iButton ) != 0; else return FALSE; } /* *********************************************************************** */ -static int hb_gt_xwc_mouse_CountButton( void ) +static int hb_gt_xwc_mouse_CountButton( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_mouse_CountButton()")); + PXWND_DEF wnd; - hb_gt_xwc_RealRefresh(); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_xwc_mouse_CountButton(%p)", pGT)); - return s_wnd->mouseNumButtons; + wnd = HB_GTXWC_GET( pGT ); + hb_gt_xwc_RealRefresh( wnd ); + + return wnd->mouseNumButtons; } /* *********************************************************************** */ -static BOOL hb_gt_xwc_SetDispCP( char * pszTermCDP, char * pszHostCDP, BOOL fBox ) +static BOOL hb_gt_xwc_SetDispCP( PHB_GT pGT, char * pszTermCDP, char * pszHostCDP, BOOL fBox ) { - HB_GTSUPER_SETDISPCP( pszTermCDP, pszHostCDP, fBox ); + HB_GTSUPER_SETDISPCP( pGT, pszTermCDP, pszHostCDP, fBox ); #ifndef HB_CDP_SUPPORT_OFF /* @@ -3529,11 +3576,13 @@ static BOOL hb_gt_xwc_SetDispCP( char * pszTermCDP, char * pszHostCDP, BOOL fBox if( pszHostCDP && *pszHostCDP ) { PHB_CODEPAGE cdpHost = hb_cdpFind( pszHostCDP ); - if( cdpHost && cdpHost != s_wnd->hostCDP ) + PXWND_DEF wnd = HB_GTXWC_GET( pGT ); + + if( cdpHost && cdpHost != wnd->hostCDP ) { - s_wnd->hostCDP = cdpHost; - if( s_wnd->fInit ) - hb_gt_xwc_BuildCharTrans( s_wnd ); + wnd->hostCDP = cdpHost; + if( wnd->fInit ) + hb_gt_xwc_BuildCharTrans( wnd ); } } #endif @@ -3543,7 +3592,7 @@ static BOOL hb_gt_xwc_SetDispCP( char * pszTermCDP, char * pszHostCDP, BOOL fBox /* *********************************************************************** */ -static BOOL hb_gt_xwc_SetKeyCP( char * pszTermCDP, char * pszHostCDP ) +static BOOL hb_gt_xwc_SetKeyCP( PHB_GT pGT, char * pszTermCDP, char * pszHostCDP ) { #ifndef HB_CDP_SUPPORT_OFF /* @@ -3566,10 +3615,11 @@ static BOOL hb_gt_xwc_SetKeyCP( char * pszTermCDP, char * pszHostCDP ) PHB_CODEPAGE cdpTerm = hb_cdpFind( pszTermCDP ); if( cdpTerm ) { - s_wnd->inCDP = cdpTerm; + HB_GTXWC_GET( pGT )->inCDP = cdpTerm; } } #else + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( pszTermCDP ); HB_SYMBOL_UNUSED( pszHostCDP ); #endif @@ -3590,20 +3640,22 @@ static int hb_gt_xwc_getKbdState( PXWND_DEF wnd ) return iKbdState; } -static BOOL hb_gt_xwc_Info( int iType, PHB_GT_INFO pInfo ) +static BOOL hb_gt_xwc_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) { + PXWND_DEF wnd; int iVal; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_xwc_Info(%d,%p)", iType, pInfo ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_xwc_Info(%p,%d,%p)", pGT, iType, pInfo ) ); - if( !s_wnd->dpy ) + wnd = HB_GTXWC_GET( pGT ); + if( !wnd->dpy ) { switch( iType ) { case GTI_FULLSCREEN: case GTI_KBDSUPPORT: case GTI_ISGRAPHIC: - hb_gt_xwc_ConnectX( s_wnd, FALSE ); + hb_gt_xwc_ConnectX( wnd, FALSE ); break; case GTI_INPUTFD: @@ -3614,7 +3666,7 @@ static BOOL hb_gt_xwc_Info( int iType, PHB_GT_INFO pInfo ) case GTI_DESKTOPCOLS: case GTI_DESKTOPROWS: case GTI_CLIPBOARDDATA: - hb_gt_xwc_ConnectX( s_wnd, TRUE ); + hb_gt_xwc_ConnectX( wnd, TRUE ); break; } } @@ -3624,48 +3676,48 @@ static BOOL hb_gt_xwc_Info( int iType, PHB_GT_INFO pInfo ) case GTI_FULLSCREEN: case GTI_KBDSUPPORT: case GTI_ISGRAPHIC: - pInfo->pResult = hb_itemPutL( pInfo->pResult, s_wnd->dpy != NULL ); + pInfo->pResult = hb_itemPutL( pInfo->pResult, wnd->dpy != NULL ); break; case GTI_INPUTFD: - pInfo->pResult = hb_itemPutNI( pInfo->pResult, ConnectionNumber( s_wnd->dpy ) ); + pInfo->pResult = hb_itemPutNI( pInfo->pResult, ConnectionNumber( wnd->dpy ) ); break; case GTI_SCREENWIDTH: - pInfo->pResult = hb_itemPutNI( pInfo->pResult, s_wnd->width ); + pInfo->pResult = hb_itemPutNI( pInfo->pResult, wnd->width ); break; case GTI_SCREENHEIGHT: - pInfo->pResult = hb_itemPutNI( pInfo->pResult, s_wnd->height ); + pInfo->pResult = hb_itemPutNI( pInfo->pResult, wnd->height ); break; case GTI_SCREENDEPTH: case GTI_DESKTOPDEPTH: pInfo->pResult = hb_itemPutNI( pInfo->pResult, - DefaultDepth( s_wnd->dpy, DefaultScreen( s_wnd->dpy ) ) ); + DefaultDepth( wnd->dpy, DefaultScreen( wnd->dpy ) ) ); break; case GTI_FONTSIZE: - pInfo->pResult = hb_itemPutNI( pInfo->pResult, s_wnd->fontHeight ); + pInfo->pResult = hb_itemPutNI( pInfo->pResult, wnd->fontHeight ); iVal = hb_itemGetNI( pInfo->pNewVal ); if( iVal > 0 ) /* TODO */ - s_wnd->fontHeight = iVal; + wnd->fontHeight = iVal; break; case GTI_FONTWIDTH: - pInfo->pResult = hb_itemPutNI( pInfo->pResult, s_wnd->fontWidth ); + pInfo->pResult = hb_itemPutNI( pInfo->pResult, wnd->fontWidth ); iVal = hb_itemGetNI( pInfo->pNewVal ); if( iVal > 0 ) /* TODO */ - s_wnd->fontWidth = iVal; + wnd->fontWidth = iVal; break; case GTI_FONTNAME: - pInfo->pResult = hb_itemPutC( pInfo->pResult, s_wnd->szFontName ); + pInfo->pResult = hb_itemPutC( pInfo->pResult, wnd->szFontName ); if( hb_itemType( pInfo->pNewVal ) & HB_IT_STRING ) /* TODO */ { - if( s_wnd->szFontName ) - hb_xfree( s_wnd->szFontName ); - s_wnd->szFontName = hb_strdup( hb_itemGetCPtr( pInfo->pNewVal ) ); + if( wnd->szFontName ) + hb_xfree( wnd->szFontName ); + wnd->szFontName = hb_strdup( hb_itemGetCPtr( pInfo->pNewVal ) ); } break; @@ -3675,7 +3727,7 @@ static BOOL hb_gt_xwc_Info( int iType, PHB_GT_INFO pInfo ) case GTI_DESKTOPROWS: { XWindowAttributes wndAttr; - XGetWindowAttributes( s_wnd->dpy, DefaultRootWindow( s_wnd->dpy ), &wndAttr ); + XGetWindowAttributes( wnd->dpy, DefaultRootWindow( wnd->dpy ), &wndAttr ); switch( iType ) { case GTI_DESKTOPWIDTH: @@ -3685,10 +3737,10 @@ static BOOL hb_gt_xwc_Info( int iType, PHB_GT_INFO pInfo ) iVal = wndAttr.height; break; case GTI_DESKTOPCOLS: - iVal = wndAttr.width / s_wnd->fontWidth; + iVal = wndAttr.width / wnd->fontWidth; break; case GTI_DESKTOPROWS: - iVal = wndAttr.height / s_wnd->fontHeight; + iVal = wndAttr.height / wnd->fontHeight; break; default: iVal = 0; @@ -3698,74 +3750,76 @@ static BOOL hb_gt_xwc_Info( int iType, PHB_GT_INFO pInfo ) } case GTI_WINTITLE: - pInfo->pResult = hb_itemPutC( pInfo->pResult, s_wnd->szTitle ); + pInfo->pResult = hb_itemPutC( pInfo->pResult, wnd->szTitle ); if( hb_itemType( pInfo->pNewVal ) & HB_IT_STRING ) { - if( s_wnd->szTitle ) - hb_xfree( s_wnd->szTitle ); + if( wnd->szTitle ) + hb_xfree( wnd->szTitle ); if( hb_itemGetCLen( pInfo->pNewVal ) > 0 ) - s_wnd->szTitle = hb_strdup( hb_itemGetCPtr( pInfo->pNewVal ) ); + wnd->szTitle = hb_strdup( hb_itemGetCPtr( pInfo->pNewVal ) ); else - s_wnd->szTitle = NULL; + wnd->szTitle = NULL; - s_wnd->fDspTitle = TRUE; + wnd->fDspTitle = TRUE; } break; case GTI_VIEWMAXWIDTH: - pInfo->pResult = hb_itemPutNI( pInfo->pResult, s_wnd->cols ); + pInfo->pResult = hb_itemPutNI( pInfo->pResult, wnd->cols ); break; case GTI_VIEWMAXHEIGHT: - pInfo->pResult = hb_itemPutNI( pInfo->pResult, s_wnd->rows ); + pInfo->pResult = hb_itemPutNI( pInfo->pResult, wnd->rows ); break; case GTI_CLIPBOARDDATA: if( hb_itemType( pInfo->pNewVal ) & HB_IT_STRING ) { - hb_gt_xwc_RealRefresh(); - hb_gt_xwc_SetSelection( s_wnd, hb_itemGetCPtr( pInfo->pNewVal ), + hb_gt_xwc_RealRefresh( wnd ); + hb_gt_xwc_SetSelection( wnd, hb_itemGetCPtr( pInfo->pNewVal ), hb_itemGetCLen( pInfo->pNewVal ) ); - hb_gt_xwc_RealRefresh(); + hb_gt_xwc_RealRefresh( wnd ); } else { - hb_gt_xwc_RealRefresh(); - hb_gt_xwc_RequestSelection( s_wnd ); + hb_gt_xwc_RealRefresh( wnd ); + hb_gt_xwc_RequestSelection( wnd ); pInfo->pResult = hb_itemPutCL( pInfo->pResult, - ( char * ) s_wnd->ClipboardData, - s_wnd->ClipboardSize ); + ( char * ) wnd->ClipboardData, + wnd->ClipboardSize ); } break; case GTI_CURSORBLINKRATE: - pInfo->pResult = hb_itemPutNI( pInfo->pResult, s_cursorBlinkRate ); + pInfo->pResult = hb_itemPutNI( pInfo->pResult, wnd->cursorBlinkRate ); if( hb_itemType( pInfo->pNewVal ) & HB_IT_NUMERIC ) - s_cursorBlinkRate = hb_itemGetNI( pInfo->pNewVal ); + wnd->cursorBlinkRate = hb_itemGetNI( pInfo->pNewVal ); break; case GTI_KBDSHIFTS: pInfo->pResult = hb_itemPutNI( pInfo->pResult, - hb_gt_xwc_getKbdState( s_wnd ) ); + hb_gt_xwc_getKbdState( wnd ) ); break; default: - return HB_GTSUPER_INFO( iType, pInfo ); + return HB_GTSUPER_INFO( pGT, iType, pInfo ); } return TRUE; } -static int hb_gt_xwc_gfx_Primitive( int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor ) +static int hb_gt_xwc_gfx_Primitive( PHB_GT pGT, int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor ) { + PXWND_DEF wnd; int iRet = 1; XColor color; - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_xwc_gfx_Primitive(%d, %d, %d, %d, %d, %d)", iType, iTop, iLeft, iBottom, iRight, iColor ) ); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_xwc_gfx_Primitive(%p,%d,%d,%d,%d,%d,%d)", pGT, iType, iTop, iLeft, iBottom, iRight, iColor ) ); - hb_gt_xwc_Initialize( s_wnd ); - hb_gt_Refresh(); + wnd = HB_GTXWC_GET( pGT ); + hb_gt_xwc_Initialize( wnd ); + HB_GTSELF_REFRESH( pGT ); switch( iType ) { @@ -3783,32 +3837,32 @@ static int hb_gt_xwc_gfx_Primitive( int iType, int iTop, int iLeft, int iBottom, color.green = iLeft * 256; color.blue = iBottom * 256; color.flags = DoRed | DoGreen | DoBlue; - hb_gt_xwc_AllocColor( s_wnd, &color ); + hb_gt_xwc_AllocColor( wnd, &color ); iRet = color.pixel; break; case GFX_CLIPTOP: - iRet = s_wnd->ClipRect.y; + iRet = wnd->ClipRect.y; break; case GFX_CLIPLEFT: - iRet = s_wnd->ClipRect.x; + iRet = wnd->ClipRect.x; break; case GFX_CLIPBOTTOM: - iRet = s_wnd->ClipRect.y + s_wnd->ClipRect.height - 1; + iRet = wnd->ClipRect.y + wnd->ClipRect.height - 1; break; case GFX_CLIPRIGHT: - iRet = s_wnd->ClipRect.x + s_wnd->ClipRect.width - 1; + iRet = wnd->ClipRect.x + wnd->ClipRect.width - 1; break; case GFX_SETCLIP: - s_wnd->ClipRect.y = iTop; - s_wnd->ClipRect.x = iLeft; - s_wnd->ClipRect.width = iBottom; - s_wnd->ClipRect.height = iRight; - XSetClipRectangles( s_wnd->dpy, s_wnd->gc, 0, 0, &s_wnd->ClipRect, 1, YXBanded ); + wnd->ClipRect.y = iTop; + wnd->ClipRect.x = iLeft; + wnd->ClipRect.width = iBottom; + wnd->ClipRect.height = iRight; + XSetClipRectangles( wnd->dpy, wnd->gc, 0, 0, &wnd->ClipRect, 1, YXBanded ); break; case GFX_DRAWINGMODE: @@ -3821,76 +3875,76 @@ static int hb_gt_xwc_gfx_Primitive( int iType, int iTop, int iLeft, int iBottom, break; case GFX_PUTPIXEL: - XSetForeground( s_wnd->dpy, s_wnd->gc, iBottom ); - XDrawPoint( s_wnd->dpy, s_wnd->drw, s_wnd->gc, iLeft, iTop ); - hb_gt_xwc_InvalidatePts( s_wnd, iLeft, iTop, iLeft, iTop ); + XSetForeground( wnd->dpy, wnd->gc, iBottom ); + XDrawPoint( wnd->dpy, wnd->drw, wnd->gc, iLeft, iTop ); + hb_gt_xwc_InvalidatePts( wnd, iLeft, iTop, iLeft, iTop ); break; case GFX_LINE: - XSetForeground( s_wnd->dpy, s_wnd->gc, iColor ); - XDrawLine( s_wnd->dpy, s_wnd->drw, s_wnd->gc, + XSetForeground( wnd->dpy, wnd->gc, iColor ); + XDrawLine( wnd->dpy, wnd->drw, wnd->gc, iLeft, iTop, iRight, iBottom ); - hb_gt_xwc_InvalidatePts( s_wnd, iLeft, iTop, iRight, iBottom ); + hb_gt_xwc_InvalidatePts( wnd, iLeft, iTop, iRight, iBottom ); break; case GFX_RECT: - XSetForeground( s_wnd->dpy, s_wnd->gc, iColor ); - XDrawRectangle( s_wnd->dpy, s_wnd->drw, s_wnd->gc, + XSetForeground( wnd->dpy, wnd->gc, iColor ); + XDrawRectangle( wnd->dpy, wnd->drw, wnd->gc, iLeft, iTop, iRight - iLeft, iBottom - iTop ); - hb_gt_xwc_InvalidatePts( s_wnd, iLeft, iTop, iRight, iBottom ); + hb_gt_xwc_InvalidatePts( wnd, iLeft, iTop, iRight, iBottom ); break; case GFX_FILLEDRECT: - XSetForeground( s_wnd->dpy, s_wnd->gc, iColor ); - XFillRectangle( s_wnd->dpy, s_wnd->drw, s_wnd->gc, + XSetForeground( wnd->dpy, wnd->gc, iColor ); + XFillRectangle( wnd->dpy, wnd->drw, wnd->gc, iLeft, iTop, iRight - iLeft, iBottom - iTop ); - hb_gt_xwc_InvalidatePts( s_wnd, iLeft, iTop, iRight, iBottom ); + hb_gt_xwc_InvalidatePts( wnd, iLeft, iTop, iRight, iBottom ); break; case GFX_CIRCLE: - XSetForeground( s_wnd->dpy, s_wnd->gc, iRight ); - XDrawArc( s_wnd->dpy, s_wnd->drw, s_wnd->gc, + XSetForeground( wnd->dpy, wnd->gc, iRight ); + XDrawArc( wnd->dpy, wnd->drw, wnd->gc, iLeft, iTop, iBottom, iBottom, 0, 360*64 ); - hb_gt_xwc_InvalidatePts( s_wnd, iLeft - iBottom, iTop - iBottom, - iLeft + iBottom, iTop + iBottom ); + hb_gt_xwc_InvalidatePts( wnd, iLeft - iBottom, iTop - iBottom, + iLeft + iBottom, iTop + iBottom ); break; case GFX_FILLEDCIRCLE: - XSetForeground( s_wnd->dpy, s_wnd->gc, iRight ); - XFillArc( s_wnd->dpy, s_wnd->drw, s_wnd->gc, + XSetForeground( wnd->dpy, wnd->gc, iRight ); + XFillArc( wnd->dpy, wnd->drw, wnd->gc, iLeft, iTop, iBottom, iBottom, 0, 360*64 ); - hb_gt_xwc_InvalidatePts( s_wnd, iLeft - iBottom, iTop - iBottom, - iLeft + iBottom, iTop + iBottom ); + hb_gt_xwc_InvalidatePts( wnd, iLeft - iBottom, iTop - iBottom, + iLeft + iBottom, iTop + iBottom ); break; case GFX_ELLIPSE: - XSetForeground( s_wnd->dpy, s_wnd->gc, iColor ); - XDrawArc( s_wnd->dpy, s_wnd->drw, s_wnd->gc, + XSetForeground( wnd->dpy, wnd->gc, iColor ); + XDrawArc( wnd->dpy, wnd->drw, wnd->gc, iLeft, iTop, iRight, iBottom, 0, 360*64 ); - hb_gt_xwc_InvalidatePts( s_wnd, iLeft - iRight, iTop - iBottom, - iLeft + iRight, iTop + iBottom ); + hb_gt_xwc_InvalidatePts( wnd, iLeft - iRight, iTop - iBottom, + iLeft + iRight, iTop + iBottom ); break; case GFX_FILLEDELLIPSE: - XSetForeground( s_wnd->dpy, s_wnd->gc, iColor ); - XFillArc( s_wnd->dpy, s_wnd->drw, s_wnd->gc, + XSetForeground( wnd->dpy, wnd->gc, iColor ); + XFillArc( wnd->dpy, wnd->drw, wnd->gc, iLeft, iTop, iRight, iBottom, 0, 360*64 ); - hb_gt_xwc_InvalidatePts( s_wnd, iLeft - iRight, iTop - iBottom, - iLeft + iRight, iTop + iBottom ); + hb_gt_xwc_InvalidatePts( wnd, iLeft - iRight, iTop - iBottom, + iLeft + iRight, iTop + iBottom ); break; case GFX_FLOODFILL: /* TODO: */ - hb_gt_xwc_InvalidatePts( s_wnd, 0, 0, s_wnd->width, s_wnd->height ); + hb_gt_xwc_InvalidatePts( wnd, 0, 0, wnd->width, wnd->height ); break; default: - return HB_GTSUPER_GFXPRIMITIVE( iType, iTop, iLeft, iBottom, iRight, iColor ); + return HB_GTSUPER_GFXPRIMITIVE( pGT, iType, iTop, iLeft, iBottom, iRight, iColor ); } - if ( hb_gt_DispCount() == 0 ) + if ( HB_GTSELF_DISPCOUNT( pGT ) == 0 ) { - hb_gt_xwc_RealRefresh(); + hb_gt_xwc_RealRefresh( wnd ); } return iRet; @@ -3898,64 +3952,70 @@ static int hb_gt_xwc_gfx_Primitive( int iType, int iTop, int iLeft, int iBottom, /* *********************************************************************** */ -static void hb_gt_xwc_Redraw( int iRow, int iCol, int iSize ) +static void hb_gt_xwc_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_xwc_Redraw(%d, %d, %d)", iRow, iCol, iSize ) ); + PXWND_DEF wnd; - if( s_wnd && !s_fNoXServer ) + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_xwc_Redraw(%p,%d,%d,%d)", pGT, iRow, iCol, iSize ) ); + + wnd = HB_GTXWC_GET( pGT ); + if( wnd && !s_fNoXServer ) { - if( s_wnd->fInit ) + if( wnd->fInit ) { #if 1 - hb_gt_xwc_InvalidateChar( s_wnd, iCol, iRow, iCol + iSize - 1, iRow ); + hb_gt_xwc_InvalidateChar( wnd, iCol, iRow, iCol + iSize - 1, iRow ); #else - hb_gt_xwc_RepaintChar( s_wnd, iCol, iRow, iCol + iSize - 1, iRow ); - iCol *= s_wnd->fontWidth; - iRow *= s_wnd->fontHeight; - hb_gt_xwc_InvalidatePts( s_wnd, iCol, iRow, - iCol + iSize * s_wnd->fontWidth - 1, - iRow + s_wnd->fontHeight - 1 ); + hb_gt_xwc_RepaintChar( wnd, iCol, iRow, iCol + iSize - 1, iRow ); + iCol *= wnd->fontWidth; + iRow *= wnd->fontHeight; + hb_gt_xwc_InvalidatePts( wnd, iCol, iRow, + iCol + iSize * wnd->fontWidth - 1, + iRow + wnd->fontHeight - 1 ); #endif } #if 0 - else if( !s_wnd->fData ) + else if( !wnd->fData ) { - BYTE bDefColor = hb_gt_GetColor(); + BYTE bDefColor = HB_GTSELF_GETCOLOR( pGT ); BYTE bColor, bAttr; USHORT usChar; while( iSize-- ) { - if( !hb_gt_GetScrChar( iRow, iCol++, &bColor, &bAttr, &usChar ) ) + if( !HB_GTSELF_GETSCRCHAR( pGT, iRow, iCol++, &bColor, &bAttr, &usChar ) ) break; if( bColor != bDefColor || usChar != ' ' ) { - s_wnd->fData = TRUE; + wnd->fData = TRUE; break; } } } #else else - s_wnd->fData = TRUE; + wnd->fData = TRUE; #endif } } /* *********************************************************************** */ -static void hb_gt_xwc_Refresh( void ) +static void hb_gt_xwc_Refresh( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ( "hb_gt_xwc_Refresh()") ); + PXWND_DEF wnd; - HB_GTSUPER_REFRESH(); + HB_TRACE( HB_TR_DEBUG, ( "hb_gt_xwc_Refresh(%p)", pGT) ); - if( s_wnd && !s_fNoXServer ) + wnd = HB_GTXWC_GET( pGT ); + HB_GTSUPER_REFRESH( pGT ); + + if( wnd && !s_fNoXServer ) { - hb_gt_GetScrCursor( &s_wnd->row, &s_wnd->col, &s_wnd->cursorType ); + HB_GTSELF_GETSCRCURSOR( pGT, &wnd->row, &wnd->col, &wnd->cursorType ); - if( s_wnd->fInit || s_wnd->fData ) - hb_gt_xwc_RealRefresh(); + if( wnd->fInit || wnd->fData ) + hb_gt_xwc_RealRefresh( wnd ); } } diff --git a/harbour/source/rtl/hbgtcore.c b/harbour/source/rtl/hbgtcore.c index 41c448d95d..7b29009c47 100644 --- a/harbour/source/rtl/hbgtcore.c +++ b/harbour/source/rtl/hbgtcore.c @@ -93,6 +93,8 @@ static void hb_gt_def_BaseInit( PHB_GT_BASE pGT ) pGT->uiExtCount = 0; pGT->uiClearChar = ' '; pGT->bClearColor = 0x07; + pGT->iHeight = 24; + pGT->iWidth = 80; pGT->hStdIn = s_hStdIn; pGT->hStdOut = s_hStdOut; pGT->hStdErr = s_hStdErr; @@ -103,20 +105,16 @@ static void hb_gt_def_BaseInit( PHB_GT_BASE pGT ) pGT->inkeyBufferSize = HB_DEFAULT_INKEY_BUFSIZE; } -static void * hb_gt_def_New( void ) +static void * hb_gt_def_New( PHB_GT pGT ) { - PHB_GT_BASE pGT; ULONG ulSize, ulIndex; USHORT usChar; BYTE bColor, bAttr; int i; - pGT = ( PHB_GT_BASE ) hb_xgrab( sizeof( HB_GT_BASE ) ); - memset( pGT, 0, sizeof( HB_GT_BASE ) ); - hb_gt_def_BaseInit( pGT ); - hb_gt_GetSize( &pGT->iHeight, &pGT->iWidth ); + HB_GTSELF_GETSIZE( pGT, &pGT->iHeight, &pGT->iWidth ); ulSize = ( ULONG ) pGT->iHeight * pGT->iWidth; pGT->screenBuffer = @@ -129,8 +127,8 @@ static void * hb_gt_def_New( void ) for( i = 0; i < pGT->iHeight; ++i ) pGT->pLines[ i ] = TRUE; - usChar = hb_gt_GetClearChar(); - bColor = hb_gt_GetClearColor(); + usChar = HB_GTSELF_GETCLEARCHAR( pGT ); + bColor = HB_GTSELF_GETCLEARCOLOR( pGT ); bAttr = 0; for( ulIndex = 0; ulIndex < ulSize; ++ulIndex ) { @@ -143,10 +141,8 @@ static void * hb_gt_def_New( void ) return pGT; } -static void hb_gt_def_Free( void * pGtPtr ) +static void hb_gt_def_Free( PHB_GT pGT ) { - PHB_GT_BASE pGT = ( PHB_GT_BASE ) pGtPtr; - if( pGT->screenBuffer ) hb_xfree( pGT->screenBuffer ); if( pGT->prevBuffer ) @@ -155,46 +151,43 @@ static void hb_gt_def_Free( void * pGtPtr ) hb_xfree( pGT->pLines ); if( pGT->iColorCount > 0 ) hb_xfree( pGT->pColor ); - if( pGT->pGTData ) - hb_xfree( pGT->pGTData ); + if( s_curGT == pGT ) + s_curGT = NULL; hb_xfree( pGT ); } -static void hb_gt_def_Init( FHANDLE hStdIn, FHANDLE hStdOut, FHANDLE hStdErr ) +static void hb_gt_def_Init( PHB_GT pGT, FHANDLE hStdIn, FHANDLE hStdOut, FHANDLE hStdErr ) { - s_curGT = ( PHB_GT_BASE ) hb_gt_New(); + HB_GTSELF_NEW( pGT ); - s_curGT->hStdIn = hStdIn; - s_curGT->hStdOut = hStdOut; - s_curGT->hStdErr = hStdErr; + pGT->hStdIn = hStdIn; + pGT->hStdOut = hStdOut; + pGT->hStdErr = hStdErr; - hb_gt_Resize( s_curGT->iHeight, s_curGT->iWidth ); - hb_mouse_Init(); - hb_mouse_GetPos( &s_curGT->iMouseLastRow, &s_curGT->iMouseLastCol ); + HB_GTSELF_RESIZE( pGT, pGT->iHeight, pGT->iWidth ); + HB_GTSELF_MOUSEINIT( pGT ); + HB_GTSELF_MOUSEGETPOS( pGT, &pGT->iMouseLastRow, &pGT->iMouseLastCol ); } -static void hb_gt_def_Exit( void ) +static void hb_gt_def_Exit( PHB_GT pGT ) { - hb_mouse_Exit(); - hb_inkey_Exit(); + HB_GTSELF_MOUSEEXIT( pGT ); + HB_GTSELF_INKEYEXIT( pGT ); + + HB_GTSELF_FREE( pGT ); - if( s_curGT ) - { - hb_gt_Free( s_curGT ); - s_curGT = NULL; - } /* clear internal clipboard data */ hb_gt_setClipboard( NULL, 0 ); } -static BOOL hb_gt_def_CheckPos( int iRow, int iCol, long *plIndex ) +static BOOL hb_gt_def_CheckPos( PHB_GT pGT, int iRow, int iCol, long *plIndex ) { if( iRow >= 0 && iCol >= 0 ) { int iHeight, iWidth; - hb_gt_GetSize( &iHeight, &iWidth ); + HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth ); if( iRow < iHeight && iCol < iWidth ) { if( plIndex ) @@ -205,94 +198,75 @@ static BOOL hb_gt_def_CheckPos( int iRow, int iCol, long *plIndex ) return FALSE; } -static void hb_gt_def_GetPos( int * piRow, int * piCol ) +static void hb_gt_def_GetPos( PHB_GT pGT, int * piRow, int * piCol ) { - if( s_curGT ) - { - * piRow = s_curGT->iRow; - * piCol = s_curGT->iCol; - } - else - * piRow = * piCol = 0; + * piRow = pGT->iRow; + * piCol = pGT->iCol; } -static void hb_gt_def_SetPos( int iRow, int iCol ) +static void hb_gt_def_SetPos( PHB_GT pGT, int iRow, int iCol ) { - if( s_curGT ) - { - s_curGT->iRow = iRow; - s_curGT->iCol = iCol; - } + pGT->iRow = iRow; + pGT->iCol = iCol; } -static int hb_gt_def_MaxCol( void ) +static int hb_gt_def_MaxCol( PHB_GT pGT ) { - if( s_curGT ) - return s_curGT->iWidth - 1; - else - return 79; + return pGT->iWidth - 1; } -static int hb_gt_def_MaxRow( void ) +static int hb_gt_def_MaxRow( PHB_GT pGT ) { - if( s_curGT ) - return s_curGT->iHeight - 1; - else - return 24; + return pGT->iHeight - 1; } -static BOOL hb_gt_def_IsColor( void ) +static BOOL hb_gt_def_IsColor( PHB_GT pGT ) { - return s_curGT && s_curGT->fIsColor; + return pGT->fIsColor; } /* NOTE: szColorString must be at least CLR_STRLEN wide by the NG. It seems that CA-Cl*pper SETCOLOR() will return string lengths up to 131+EOF. That seems like a 127+1 buffer size, plus lazy overflow checking. [vszakats] */ -static void hb_gt_def_GetColorStr( char * pszColorString ) +static void hb_gt_def_GetColorStr( PHB_GT pGT, char * pszColorString ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_GetColorStr(%s)", pszColorString)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_GetColorStr(%p,%s)", pGT, pszColorString)); - if( s_curGT ) - hb_gt_ColorsToString( s_curGT->pColor, s_curGT->iColorCount, - pszColorString, CLR_STRLEN ); + HB_GTSELF_COLORSTOSTRING( pGT, pGT->pColor, pGT->iColorCount, + pszColorString, CLR_STRLEN ); } -static void hb_gt_def_SetColorStr( const char * szColorString ) +static void hb_gt_def_SetColorStr( PHB_GT pGT, const char * szColorString ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_SetColorStr(%s)", szColorString)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_SetColorStr(%p,%s)", pGT, szColorString)); - if( s_curGT ) - { - hb_gt_StringToColors( szColorString, &s_curGT->pColor, &s_curGT->iColorCount ); - - s_curGT->iColorIndex = HB_CLR_STANDARD; /* hb_gt_ColorSelect( HB_CLR_STANDARD ); */ - } + HB_GTSELF_STRINGTOCOLORS( pGT, szColorString, &pGT->pColor, &pGT->iColorCount ); + pGT->iColorIndex = HB_CLR_STANDARD; /* HB_GTSELF_COLORSELECT( pGT, HB_CLR_STANDARD ); */ } -static void hb_gt_def_ColorSelect( int iColorIndex ) +static void hb_gt_def_ColorSelect( PHB_GT pGT, int iColorIndex ) { - if( s_curGT && iColorIndex >= 0 && iColorIndex < s_curGT->iColorCount ) - s_curGT->iColorIndex = iColorIndex; + if( iColorIndex >= 0 && iColorIndex < pGT->iColorCount ) + pGT->iColorIndex = iColorIndex; } -static int hb_gt_def_GetColor( void ) +static int hb_gt_def_GetColor( PHB_GT pGT ) { - if( s_curGT && s_curGT->iColorCount ) - return s_curGT->pColor[ s_curGT->iColorIndex ]; + if( pGT->iColorCount ) + return pGT->pColor[ pGT->iColorIndex ]; else - return hb_gt_GetClearColor(); + return HB_GTSELF_GETCLEARCOLOR( pGT ); } -static void hb_gt_def_GetColorData( int ** pColorsPtr, int * piColorCount, int * piColorIndex ) +static void hb_gt_def_GetColorData( PHB_GT pGT, int ** pColorsPtr, int * piColorCount, int * piColorIndex ) { - if( s_curGT && s_curGT->iColorCount ) + if( pGT->iColorCount ) { - *pColorsPtr = ( int * ) hb_xgrab( s_curGT->iColorCount * sizeof( int ) ); - memcpy( *pColorsPtr, s_curGT->pColor, s_curGT->iColorCount * sizeof( int ) ); - *piColorCount = s_curGT->iColorCount; - *piColorIndex = s_curGT->iColorIndex; + *pColorsPtr = ( int * ) hb_xgrab( pGT->iColorCount * sizeof( int ) ); + memcpy( *pColorsPtr, pGT->pColor, pGT->iColorCount * sizeof( int ) ); + *piColorCount = pGT->iColorCount; + *piColorIndex = pGT->iColorIndex; } else { @@ -303,26 +277,24 @@ static void hb_gt_def_GetColorData( int ** pColorsPtr, int * piColorCount, int * } } -static int hb_gt_def_GetClearColor( void ) +static int hb_gt_def_GetClearColor( PHB_GT pGT ) { - return s_curGT ? s_curGT->bClearColor : 0x07; + return pGT->bClearColor; } -static void hb_gt_def_SetClearColor( int iColor ) +static void hb_gt_def_SetClearColor( PHB_GT pGT, int iColor ) { - if( s_curGT ) - s_curGT->bClearColor = iColor; + pGT->bClearColor = iColor; } -static int hb_gt_def_GetClearChar( void ) +static int hb_gt_def_GetClearChar( PHB_GT pGT ) { - return s_curGT ? s_curGT->uiClearChar : ' '; + return pGT->uiClearChar; } -static void hb_gt_def_SetClearChar( int iChar ) +static void hb_gt_def_SetClearChar( PHB_GT pGT, int iChar ) { - if( s_curGT ) - s_curGT->uiClearChar = iChar; + pGT->uiClearChar = iChar; } /* helper internal function */ @@ -339,7 +311,7 @@ static const char * hb_gt_def_ColorDecode( const char * szColorString, int * piC int nColor = 0; BOOL bFore = TRUE; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_ColorDecode(%p)", szColorString, piColor)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_ColorDecode(%s,%p)", szColorString, piColor)); while( ( c = *szColorString++ ) != 0 ) { @@ -428,22 +400,25 @@ static const char * hb_gt_def_ColorDecode( const char * szColorString, int * piC return NULL; } -static int hb_gt_def_ColorNum( const char * szColorString ) +static int hb_gt_def_ColorNum( PHB_GT pGT, const char * szColorString ) { int nColor; + HB_SYMBOL_UNUSED( pGT ); hb_gt_def_ColorDecode( szColorString, &nColor ); return nColor; } -static void hb_gt_def_StringToColors( const char * szColorString, int ** pColorsPtr, int * piColorCount ) +static void hb_gt_def_StringToColors( PHB_GT pGT, const char * szColorString, int ** pColorsPtr, int * piColorCount ) { int * pColors; int nPos = 0; int nColor; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_StringToColors(%s,%p,%p)", szColorString, pColorsPtr, piColorCount)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_StringToColors(%p,%s,%p,%p)", pGT, szColorString, pColorsPtr, piColorCount)); + + HB_SYMBOL_UNUSED( pGT ); if( *piColorCount == 0 ) { @@ -481,14 +456,16 @@ static void hb_gt_def_StringToColors( const char * szColorString, int ** pColors pColors[ HB_CLR_UNSELECTED ] = pColors[ HB_CLR_ENHANCED ]; } -static void hb_gt_def_ColorsToString( int * pColors, int iColorCount, char * pszColorString, int iBufSize ) +static void hb_gt_def_ColorsToString( PHB_GT pGT, int * pColors, int iColorCount, char * pszColorString, int iBufSize ) { - int iColorIndex, iPos = 0; + int iColorIndex, iPos; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_ColorsToString(%p,%d,%s,%d)", pColors, iColorCount, pszColorString, iBufSize)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_ColorsToString(%p,%p,%d,%s,%d)", pGT, pColors, iColorCount, pszColorString, iBufSize)); + + HB_SYMBOL_UNUSED( pGT ); /* Go on if there's space left for the largest color string plus EOF */ - for( iColorIndex = 0; iColorIndex < iColorCount && iPos < iBufSize - 8; ++iColorIndex ) + for( iColorIndex = iPos = 0; iColorIndex < iColorCount && iPos < iBufSize - 8; ++iColorIndex ) { int nColor = pColors[ iColorIndex ] & 7; int j; @@ -551,16 +528,13 @@ static void hb_gt_def_ColorsToString( int * pColors, int iColorCount, char * psz } -static int hb_gt_def_GetCursorStyle( void ) +static int hb_gt_def_GetCursorStyle( PHB_GT pGT ) { - return s_curGT ? s_curGT->iCursorShape : SC_UNDEF; + return pGT->iCursorShape; } -static void hb_gt_def_SetCursorStyle( int iStyle ) +static void hb_gt_def_SetCursorStyle( PHB_GT pGT, int iStyle ) { - if( !s_curGT ) - return; - switch( iStyle ) { case SC_NONE: @@ -568,35 +542,35 @@ static void hb_gt_def_SetCursorStyle( int iStyle ) case SC_INSERT: case SC_SPECIAL1: case SC_SPECIAL2: - s_curGT->iCursorShape = iStyle; + pGT->iCursorShape = iStyle; break; default: - s_curGT->iCursorShape = SC_NORMAL; + pGT->iCursorShape = SC_NORMAL; break; } } -static void hb_gt_def_GetScrCursor( int * piRow, int * piCol, int * piStyle ) +static void hb_gt_def_GetScrCursor( PHB_GT pGT, int * piRow, int * piCol, int * piStyle ) { - hb_gt_GetPos( piRow, piCol ); - if( *piRow < 0 || *piCol < 0 || *piRow > hb_gt_MaxRow() || *piCol > hb_gt_MaxCol() ) + HB_GTSELF_GETPOS( pGT, piRow, piCol ); + if( *piRow < 0 || *piCol < 0 || + *piRow > HB_GTSELF_MAXROW( pGT ) || *piCol > HB_GTSELF_MAXCOL( pGT ) ) *piStyle = SC_NONE; else - *piStyle = hb_gt_GetCursorStyle(); + *piStyle = HB_GTSELF_GETCURSORSTYLE( pGT ); } -static BOOL hb_gt_def_GetBlink( void ) +static BOOL hb_gt_def_GetBlink( PHB_GT pGT ) { - return s_curGT && s_curGT->fBlinking; + return pGT->fBlinking; } -static void hb_gt_def_SetBlink( BOOL fBlink ) +static void hb_gt_def_SetBlink( PHB_GT pGT, BOOL fBlink ) { - if( s_curGT ) - s_curGT->fBlinking = fBlink; + pGT->fBlinking = fBlink; } -static void hb_gt_def_SetSnowFlag( BOOL fNoSnow ) +static void hb_gt_def_SetSnowFlag( PHB_GT pGT, BOOL fNoSnow ) { /* * NOTE: This is a compatibility function which have to be implemented @@ -604,193 +578,171 @@ static void hb_gt_def_SetSnowFlag( BOOL fNoSnow ) * If you're running on a CGA and snow is a problem speak up! */ + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( fNoSnow ); } -static void hb_gt_def_DispBegin( void ) +static void hb_gt_def_DispBegin( PHB_GT pGT ) { - if( s_curGT ) - s_curGT->uiDispCount++; + pGT->uiDispCount++; } -static void hb_gt_def_DispEnd( void ) +static void hb_gt_def_DispEnd( PHB_GT pGT ) { - if( s_curGT ) - { - if( s_curGT->uiDispCount > 0 ) - s_curGT->uiDispCount--; - } + if( pGT->uiDispCount > 0 ) + pGT->uiDispCount--; } -static int hb_gt_def_DispCount( void ) +static int hb_gt_def_DispCount( PHB_GT pGT ) { - return s_curGT && s_curGT->uiDispCount; + return pGT->uiDispCount; } -static BOOL hb_gt_def_PreExt( void ) +static BOOL hb_gt_def_PreExt( PHB_GT pGT ) { - if( s_curGT ) - { - if( s_curGT->uiExtCount == 0 ) - hb_gt_Refresh(); - s_curGT->uiExtCount++; - } + if( pGT->uiExtCount == 0 ) + HB_GTSELF_REFRESH( pGT ); + pGT->uiExtCount++; return TRUE; } -static BOOL hb_gt_def_PostExt( void ) +static BOOL hb_gt_def_PostExt( PHB_GT pGT ) { - if( s_curGT ) - { - if( s_curGT->uiExtCount ) - s_curGT->uiExtCount--; - } + if( pGT->uiExtCount ) + pGT->uiExtCount--; return TRUE; } -static BOOL hb_gt_def_Suspend( void ) +static BOOL hb_gt_def_Suspend( PHB_GT pGT ) { - return hb_gt_PreExt(); + return HB_GTSELF_PREEXT( pGT ); } -static BOOL hb_gt_def_Resume( void ) +static BOOL hb_gt_def_Resume( PHB_GT pGT ) { - return hb_gt_PostExt(); + return HB_GTSELF_POSTEXT( pGT ); } -static void hb_gt_def_OutStd( BYTE * pbyStr, ULONG ulLen ) +static void hb_gt_def_OutStd( PHB_GT pGT, BYTE * pbyStr, ULONG ulLen ) { if( ulLen ) { - if( s_curGT ) - { - if( s_curGT->fStdOutCon ) - hb_gt_WriteCon( pbyStr, ulLen ); - else - { - hb_gt_PreExt(); - if( s_curGT->fDispTrans ) - { - BYTE * pbyStrBuff = ( BYTE * ) hb_xgrab( ulLen ); - memcpy( pbyStrBuff, pbyStr, ulLen ); - hb_cdpnTranslate( ( char * ) pbyStrBuff, - s_curGT->cdpHost, s_curGT->cdpTerm, ulLen ); - hb_fsWriteLarge( s_curGT->hStdOut, pbyStrBuff, ulLen ); - hb_xfree( pbyStrBuff ); - } - else - hb_fsWriteLarge( s_curGT->hStdOut, pbyStr, ulLen ); - hb_gt_PostExt(); - } - } + if( pGT->fStdOutCon ) + HB_GTSELF_WRITECON( pGT, pbyStr, ulLen ); else - hb_fsWriteLarge( s_hStdOut, pbyStr, ulLen ); + { + HB_GTSELF_PREEXT( pGT ); + if( pGT->fDispTrans ) + { + BYTE * pbyStrBuff = ( BYTE * ) hb_xgrab( ulLen ); + memcpy( pbyStrBuff, pbyStr, ulLen ); + hb_cdpnTranslate( ( char * ) pbyStrBuff, + pGT->cdpHost, pGT->cdpTerm, ulLen ); + hb_fsWriteLarge( pGT->hStdOut, pbyStrBuff, ulLen ); + hb_xfree( pbyStrBuff ); + } + else + hb_fsWriteLarge( pGT->hStdOut, pbyStr, ulLen ); + HB_GTSELF_POSTEXT( pGT ); + } } } -static void hb_gt_def_OutErr( BYTE * pbyStr, ULONG ulLen ) +static void hb_gt_def_OutErr( PHB_GT pGT, BYTE * pbyStr, ULONG ulLen ) { if( ulLen ) { - if( s_curGT ) - { - if( s_curGT->fStdErrCon ) - hb_gt_WriteCon( pbyStr, ulLen ); - else - { - hb_gt_PreExt(); - if( s_curGT->fDispTrans ) - { - BYTE * pbyStrBuff = ( BYTE * ) hb_xgrab( ulLen ); - memcpy( pbyStrBuff, pbyStr, ulLen ); - hb_cdpnTranslate( ( char * ) pbyStrBuff, - s_curGT->cdpHost, s_curGT->cdpTerm, ulLen ); - hb_fsWriteLarge( s_curGT->hStdErr, pbyStrBuff, ulLen ); - hb_xfree( pbyStrBuff ); - } - else - hb_fsWriteLarge( s_curGT->hStdErr, pbyStr, ulLen ); - hb_gt_PostExt(); - } - } + if( pGT->fStdErrCon ) + HB_GTSELF_WRITECON( pGT, pbyStr, ulLen ); else - hb_fsWriteLarge( s_hStdErr, pbyStr, ulLen ); + { + HB_GTSELF_PREEXT( pGT ); + if( pGT->fDispTrans ) + { + BYTE * pbyStrBuff = ( BYTE * ) hb_xgrab( ulLen ); + memcpy( pbyStrBuff, pbyStr, ulLen ); + hb_cdpnTranslate( ( char * ) pbyStrBuff, + pGT->cdpHost, pGT->cdpTerm, ulLen ); + hb_fsWriteLarge( pGT->hStdErr, pbyStrBuff, ulLen ); + hb_xfree( pbyStrBuff ); + } + else + hb_fsWriteLarge( pGT->hStdErr, pbyStr, ulLen ); + HB_GTSELF_POSTEXT( pGT ); + } } } -static void hb_gt_def_Tone( double dFrequency, double dDuration ) +static void hb_gt_def_Tone( PHB_GT pGT, double dFrequency, double dDuration ) { + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( dFrequency ); /* convert Clipper (DOS) timer tick units to seconds ( x / 18.2 ) */ hb_idleSleep( dDuration / 18.2 ); } -static void hb_gt_def_Bell( void ) +static void hb_gt_def_Bell( PHB_GT pGT ) { - hb_gt_Tone( 700.0, 3.0 ); + HB_GTSELF_TONE( pGT, 700.0, 3.0 ); } -static char * hb_gt_def_Version( int iType ) +static char * hb_gt_def_Version( PHB_GT pGT, int iType ) { + HB_SYMBOL_UNUSED( pGT ); + if( iType == 0 ) return "NUL"; return "Harbour Terminal: NULL"; } -static BOOL hb_gt_def_GetChar( int iRow, int iCol, +static BOOL hb_gt_def_GetChar( PHB_GT pGT, int iRow, int iCol, BYTE * pbColor, BYTE * pbAttr, USHORT * pusChar ) { - if( s_curGT ) - { - long lIndex; + long lIndex; - if( hb_gt_CheckPos( iRow, iCol, &lIndex ) ) - { - *pusChar = s_curGT->screenBuffer[ lIndex ].c.usChar; - *pbColor = s_curGT->screenBuffer[ lIndex ].c.bColor; - *pbAttr = s_curGT->screenBuffer[ lIndex ].c.bAttr; - return TRUE; - } + if( HB_GTSELF_CHECKPOS( pGT, iRow, iCol, &lIndex ) ) + { + *pusChar = pGT->screenBuffer[ lIndex ].c.usChar; + *pbColor = pGT->screenBuffer[ lIndex ].c.bColor; + *pbAttr = pGT->screenBuffer[ lIndex ].c.bAttr; + return TRUE; } return FALSE; } -static BOOL hb_gt_def_PutChar( int iRow, int iCol, +static BOOL hb_gt_def_PutChar( PHB_GT pGT, int iRow, int iCol, BYTE bColor, BYTE bAttr, USHORT usChar ) { - if( s_curGT ) - { - long lIndex; + long lIndex; - if( hb_gt_CheckPos( iRow, iCol, &lIndex ) ) - { - s_curGT->screenBuffer[ lIndex ].c.usChar = usChar; - s_curGT->screenBuffer[ lIndex ].c.bColor = bColor; - s_curGT->screenBuffer[ lIndex ].c.bAttr = bAttr; - s_curGT->pLines[ iRow ] = TRUE; - s_curGT->fRefresh = TRUE; - return TRUE; - } + if( HB_GTSELF_CHECKPOS( pGT, iRow, iCol, &lIndex ) ) + { + pGT->screenBuffer[ lIndex ].c.usChar = usChar; + pGT->screenBuffer[ lIndex ].c.bColor = bColor; + pGT->screenBuffer[ lIndex ].c.bAttr = bAttr; + pGT->pLines[ iRow ] = TRUE; + pGT->fRefresh = TRUE; + return TRUE; } return FALSE; } -static void hb_gt_def_PutText( int iRow, int iCol, BYTE bColor, BYTE * pText, ULONG ulLen ) +static void hb_gt_def_PutText( PHB_GT pGT, int iRow, int iCol, BYTE bColor, BYTE * pText, ULONG ulLen ) { while( ulLen-- ) { - if( !hb_gt_PutChar( iRow, iCol, bColor, 0, *pText++ ) ) + if( !HB_GTSELF_PUTCHAR( pGT, iRow, iCol, bColor, 0, *pText++ ) ) break; ++iCol; } } -static void hb_gt_def_Replicate( int iRow, int iCol, BYTE bColor, BYTE bAttr, - USHORT usChar, ULONG ulLen ) +static void hb_gt_def_Replicate( PHB_GT pGT, int iRow, int iCol, BYTE bColor, + BYTE bAttr, USHORT usChar, ULONG ulLen ) { if( iCol < 0 ) { @@ -802,35 +754,35 @@ static void hb_gt_def_Replicate( int iRow, int iCol, BYTE bColor, BYTE bAttr, } while( ulLen-- ) { - if( !hb_gt_PutChar( iRow, iCol, bColor, bAttr, usChar ) ) + if( !HB_GTSELF_PUTCHAR( pGT, iRow, iCol, bColor, bAttr, usChar ) ) break; ++iCol; } } -static void hb_gt_def_WriteAt( int iRow, int iCol, BYTE * pText, ULONG ulLength ) +static void hb_gt_def_WriteAt( PHB_GT pGT, int iRow, int iCol, BYTE * pText, ULONG ulLength ) { - int iMaxCol = hb_gt_MaxCol(); + int iMaxCol = HB_GTSELF_MAXCOL( pGT ); /* Truncate the text if the cursor will end up off the right edge */ - hb_gt_PutText( iRow, iCol, ( BYTE ) hb_gt_GetColor(), pText, - HB_MIN( ulLength, ( ULONG ) ( iMaxCol - iCol + 1 ) ) ); + HB_GTSELF_PUTTEXT( pGT, iRow, iCol, HB_GTSELF_GETCOLOR( pGT ), pText, + HB_MIN( ulLength, ( ULONG ) ( iMaxCol - iCol + 1 ) ) ); /* Finally, save the new cursor position, even if off-screen */ - hb_gt_SetPos( iRow, iCol + ( int ) ulLength ); + HB_GTSELF_SETPOS( pGT, iRow, iCol + ( int ) ulLength ); } -static void hb_gt_def_Write( BYTE * pText, ULONG ulLength ) +static void hb_gt_def_Write( PHB_GT pGT, BYTE * pText, ULONG ulLength ) { int iRow, iCol; - hb_gt_GetPos( &iRow, &iCol ); - hb_gt_WriteAt( iRow, iCol, pText, ulLength ); + HB_GTSELF_GETPOS( pGT, &iRow, &iCol ); + HB_GTSELF_WRITEAT( pGT, iRow, iCol, pText, ulLength ); } #define WRITECON_BUFFER_SIZE 512 -static void hb_gt_def_WriteCon( BYTE * pText, ULONG ulLength ) +static void hb_gt_def_WriteCon( PHB_GT pGT, BYTE * pText, ULONG ulLength ) { int iLen = 0; BOOL bDisp = FALSE; @@ -839,10 +791,10 @@ static void hb_gt_def_WriteCon( BYTE * pText, ULONG ulLength ) int iRow, iCol, iMaxRow, iMaxCol; BYTE szString[ WRITECON_BUFFER_SIZE ]; - iMaxRow = hb_gt_MaxRow(); - iMaxCol = hb_gt_MaxCol(); + iMaxRow = HB_GTSELF_MAXROW( pGT ); + iMaxCol = HB_GTSELF_MAXCOL( pGT ); - hb_gt_GetPos( &iRow, &iCol ); + HB_GTSELF_GETPOS( pGT, &iRow, &iCol ); /* Limit the starting cursor position to maxrow(),maxcol() on the high end, but don't limit it on the low end. */ @@ -853,7 +805,7 @@ static void hb_gt_def_WriteCon( BYTE * pText, ULONG ulLength ) iRow = iMaxRow; if( iCol > iMaxCol ) iCol = iMaxCol; - hb_gt_SetPos( iRow, iCol ); + HB_GTSELF_SETPOS( pGT, iRow, iCol ); } while( ulLength-- ) @@ -884,7 +836,7 @@ static void hb_gt_def_WriteCon( BYTE * pText, ULONG ulLength ) szString[ iLen - 1 ] = ' '; else { - hb_gt_SetPos( iRow, iCol ); + HB_GTSELF_SETPOS( pGT, iRow, iCol ); szString[ iLen++ ] = ' '; } } @@ -935,13 +887,14 @@ static void hb_gt_def_WriteCon( BYTE * pText, ULONG ulLength ) if( bDisp || ulLength == 0 ) { if( iLen ) - hb_gt_Write( szString, iLen ); + HB_GTSELF_WRITE( pGT, szString, iLen ); iLen = 0; if( iRow > iMaxRow ) { /* Normal scroll */ - hb_gt_Scroll( 0, 0, iMaxRow, iMaxCol, ( BYTE ) hb_gt_GetColor(), hb_gt_GetClearChar(), iRow - iMaxRow, 0 ); + HB_GTSELF_SCROLL( pGT, 0, 0, iMaxRow, iMaxCol, HB_GTSELF_GETCOLOR( pGT ), + HB_GTSELF_GETCLEARCHAR( pGT ), iRow - iMaxRow, 0 ); iRow = iMaxRow; iCol = 0; } @@ -949,38 +902,39 @@ static void hb_gt_def_WriteCon( BYTE * pText, ULONG ulLength ) { /* Special case scroll when newline and cursor off top edge of display */ - hb_gt_Scroll( 0, 0, iMaxRow, iMaxCol, ( BYTE ) hb_gt_GetColor(), hb_gt_GetClearChar(), 1, 0 ); + HB_GTSELF_SCROLL( pGT, 0, 0, iMaxRow, iMaxCol, HB_GTSELF_GETCOLOR( pGT ), + HB_GTSELF_GETCLEARCHAR( pGT ), 1, 0 ); } - hb_gt_SetPos( iRow, iCol ); + HB_GTSELF_SETPOS( pGT, iRow, iCol ); bDisp = FALSE; bNewLine = FALSE; /* To emulate scrolling */ - hb_gt_Flush(); + HB_GTSELF_FLUSH( pGT ); if( bBell ) { - hb_gt_Bell(); + HB_GTSELF_BELL( pGT ); bBell = FALSE; } } } } -static long hb_gt_def_RectSize( int iTop, int iLeft, int iBottom, int iRight ) +static long hb_gt_def_RectSize( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight ) { int iRows, iCols; iRows = iBottom - iTop + 1; iCols = iRight - iLeft + 1; - if( !s_curGT || iCols <= 0 || iRows <= 0 ) + if( iCols <= 0 || iRows <= 0 ) return 0; else - return ( ( long ) iRows * iCols ) << ( s_curGT->fVgaCell ? 1 : 2 ); + return ( ( long ) iRows * iCols ) << ( pGT->fVgaCell ? 1 : 2 ); } -static void hb_gt_def_Save( int iTop, int iLeft, int iBottom, int iRight, +static void hb_gt_def_Save( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE * pBuffer ) { while( iTop <= iBottom ) @@ -991,13 +945,13 @@ static void hb_gt_def_Save( int iTop, int iLeft, int iBottom, int iRight, for( iCol = iLeft; iCol <= iRight; ++iCol ) { - if( !hb_gt_GetChar( iTop, iCol, &bColor, &bAttr, &usChar ) ) + if( !HB_GTSELF_GETCHAR( pGT, iTop, iCol, &bColor, &bAttr, &usChar ) ) { - usChar = hb_gt_GetClearChar(); - bColor = hb_gt_GetClearColor(); + usChar = HB_GTSELF_GETCLEARCHAR( pGT ); + bColor = HB_GTSELF_GETCLEARCOLOR( pGT ); bAttr = 0x00; } - if( s_curGT && s_curGT->fVgaCell ) + if( pGT->fVgaCell ) { *pBuffer++ = ( BYTE ) usChar; *pBuffer++ = bColor; @@ -1014,7 +968,7 @@ static void hb_gt_def_Save( int iTop, int iLeft, int iBottom, int iRight, } } -static void hb_gt_def_Rest( int iTop, int iLeft, int iBottom, int iRight, +static void hb_gt_def_Rest( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE * pBuffer ) { while( iTop <= iBottom ) @@ -1025,7 +979,7 @@ static void hb_gt_def_Rest( int iTop, int iLeft, int iBottom, int iRight, for( iCol = iLeft; iCol <= iRight; ++iCol ) { - if( s_curGT && s_curGT->fVgaCell ) + if( pGT->fVgaCell ) { usChar = *pBuffer++; bColor = *pBuffer++; @@ -1038,13 +992,13 @@ static void hb_gt_def_Rest( int iTop, int iLeft, int iBottom, int iRight, bColor = *pBuffer++; bAttr = *pBuffer++; } - hb_gt_PutChar( iTop, iCol, bColor, bAttr, usChar ); + HB_GTSELF_PUTCHAR( pGT, iTop, iCol, bColor, bAttr, usChar ); } ++iTop; } } -static void hb_gt_def_SetAttribute( int iTop, int iLeft, int iBottom, int iRight, +static void hb_gt_def_SetAttribute( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE bColor ) { while( iTop <= iBottom ) @@ -1055,16 +1009,16 @@ static void hb_gt_def_SetAttribute( int iTop, int iLeft, int iBottom, int iRight for( iCol = iLeft; iCol <= iRight; ++iCol ) { - if( !hb_gt_GetChar( iTop, iCol, &bColorOld, &bAttr, &usChar ) ) + if( !HB_GTSELF_GETCHAR( pGT, iTop, iCol, &bColorOld, &bAttr, &usChar ) ) break; - if( !hb_gt_PutChar( iTop, iCol, bColor, bAttr, usChar ) ) + if( !HB_GTSELF_PUTCHAR( pGT, iTop, iCol, bColor, bAttr, usChar ) ) break; } ++iTop; } } -static void hb_gt_def_DrawShadow( int iTop, int iLeft, int iBottom, int iRight, +static void hb_gt_def_DrawShadow( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE bColor ) { int iMaxRow, iMaxCol, i; @@ -1085,22 +1039,22 @@ static void hb_gt_def_DrawShadow( int iTop, int iLeft, int iBottom, int iRight, iLeft += 2; ++iBottom; - iMaxRow = hb_gt_MaxRow(); - iMaxCol = hb_gt_MaxCol(); + iMaxRow = HB_GTSELF_MAXROW( pGT ); + iMaxCol = HB_GTSELF_MAXCOL( pGT ); /* Draw the bottom edge */ if( iBottom <= iMaxRow && iLeft <= iMaxCol ) - hb_gt_SetAttribute( iBottom, iLeft, iBottom, HB_MIN( iRight, iMaxCol ), bColor ); + HB_GTSELF_SETATTRIBUTE( pGT, iBottom, iLeft, iBottom, HB_MIN( iRight, iMaxCol ), bColor ); ++iRight; ++iTop; /* Draw the right edge */ if( iTop <= iMaxRow && iRight <= iMaxCol ) - hb_gt_SetAttribute( iTop, iRight, iBottom, HB_MIN( iRight + 1, iMaxCol ), bColor ); + HB_GTSELF_SETATTRIBUTE( pGT, iTop, iRight, iBottom, HB_MIN( iRight + 1, iMaxCol ), bColor ); } -static void hb_gt_def_Scroll( int iTop, int iLeft, int iBottom, int iRight, +static void hb_gt_def_Scroll( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE bColor, BYTE bChar, int iRows, int iCols ) { int iColOld, iColNew, iColSize, iColClear, iClrs, iLength; @@ -1129,7 +1083,7 @@ static void hb_gt_def_Scroll( int iTop, int iLeft, int iBottom, int iRight, if( ( iRows || iCols ) && iColSize >= 0 && ( iBottom - iTop >= iRows ) ) { - ULONG ulSize = hb_gt_RectSize( iTop, iColOld, iTop, iColOld + iColSize ); + ULONG ulSize = HB_GTSELF_RECTSIZE( pGT, iTop, iColOld, iTop, iColOld + iColSize ); if( ulSize ) pBuffer = ( BYTE * ) hb_xgrab( ulSize ); @@ -1146,13 +1100,13 @@ static void hb_gt_def_Scroll( int iTop, int iLeft, int iBottom, int iRight, if( pBuffer && iRowPos + iRows >= iTop && iRowPos + iRows <= iBottom ) { - hb_gt_Save( iRowPos + iRows, iColOld, iRowPos + iRows, iColOld + iColSize, pBuffer ); - hb_gt_Rest( iRowPos, iColNew, iRowPos, iColNew + iColSize, pBuffer ); + HB_GTSELF_SAVE( pGT, iRowPos + iRows, iColOld, iRowPos + iRows, iColOld + iColSize, pBuffer ); + HB_GTSELF_REST( pGT, iRowPos, iColNew, iRowPos, iColNew + iColSize, pBuffer ); if( iClrs ) - hb_gt_Replicate( iRowPos, iColClear, bColor, 0, bChar, iClrs ); + HB_GTSELF_REPLICATE( pGT, iRowPos, iColClear, bColor, 0, bChar, iClrs ); } else - hb_gt_Replicate( iRowPos, iLeft, bColor, 0, bChar, iLength ); + HB_GTSELF_REPLICATE( pGT, iRowPos, iLeft, bColor, 0, bChar, iLength ); } if( pBuffer ) @@ -1160,14 +1114,14 @@ static void hb_gt_def_Scroll( int iTop, int iLeft, int iBottom, int iRight, } } -static void hb_gt_def_ScrollArea( int iTop, int iLeft, int iBottom, int iRight, +static void hb_gt_def_ScrollArea( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE bColor, BYTE bChar, int iRows, int iCols ) { - if( s_curGT && ( iRows || iCols ) ) + if( iRows || iCols ) { int iColOld, iColNew, iColSize, iColClear, iClrs, iLength, iHeight, iWidth; - hb_gt_GetSize( &iHeight, &iWidth ); + HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth ); if( iTop < 0 ) iTop = 0; if( iLeft < 0 ) @@ -1218,51 +1172,51 @@ static void hb_gt_def_ScrollArea( int iTop, int iLeft, int iBottom, int iRight, { for( i = 0; i <= iColSize; ++i, ++lIndex ) { - s_curGT->screenBuffer[ lIndex ].uiValue = - s_curGT->screenBuffer[ lIndex + lOffset ].uiValue; - s_curGT->prevBuffer[ lIndex ].uiValue = - s_curGT->prevBuffer[ lIndex + lOffset ].uiValue; + pGT->screenBuffer[ lIndex ].uiValue = + pGT->screenBuffer[ lIndex + lOffset ].uiValue; + pGT->prevBuffer[ lIndex ].uiValue = + pGT->prevBuffer[ lIndex + lOffset ].uiValue; } } else { for( i = iColSize, lIndex += iColSize; i >= 0; --i, --lIndex ) { - s_curGT->screenBuffer[ lIndex ].uiValue = - s_curGT->screenBuffer[ lIndex + lOffset ].uiValue; - s_curGT->prevBuffer[ lIndex ].uiValue = - s_curGT->prevBuffer[ lIndex + lOffset ].uiValue; + pGT->screenBuffer[ lIndex ].uiValue = + pGT->screenBuffer[ lIndex + lOffset ].uiValue; + pGT->prevBuffer[ lIndex ].uiValue = + pGT->prevBuffer[ lIndex + lOffset ].uiValue; } } if( iClrs ) - hb_gt_Replicate( iRowPos, iColClear, bColor, 0, bChar, iClrs ); + HB_GTSELF_REPLICATE( pGT, iRowPos, iColClear, bColor, 0, bChar, iClrs ); } else - hb_gt_Replicate( iRowPos, iLeft, bColor, 0, bChar, iLength ); + HB_GTSELF_REPLICATE( pGT, iRowPos, iLeft, bColor, 0, bChar, iLength ); } } } } -static void hb_gt_def_ScrollUp( int iRows, BYTE bColor, BYTE bChar ) +static void hb_gt_def_ScrollUp( PHB_GT pGT, int iRows, BYTE bColor, BYTE bChar ) { - if( s_curGT && iRows > 0 ) + if( iRows > 0 ) { int i, j, iHeight, iWidth; long lIndex = 0, lOffset; BYTE bAttr = 0; - hb_gt_GetSize( &iHeight, &iWidth ); + HB_GTSELF_GETSIZE( pGT, &iHeight, &iWidth ); lOffset = ( long ) iRows * iWidth; for( i = iRows; i < iHeight; ++i ) { - s_curGT->pLines[ i - iRows ] = s_curGT->pLines[ i ]; + pGT->pLines[ i - iRows ] = pGT->pLines[ i ]; for( j = 0; j < iWidth; ++j ) { - s_curGT->screenBuffer[ lIndex ].uiValue = - s_curGT->screenBuffer[ lIndex + lOffset ].uiValue; - s_curGT->prevBuffer[ lIndex ].uiValue = - s_curGT->prevBuffer[ lIndex + lOffset ].uiValue; + pGT->screenBuffer[ lIndex ].uiValue = + pGT->screenBuffer[ lIndex + lOffset ].uiValue; + pGT->prevBuffer[ lIndex ].uiValue = + pGT->prevBuffer[ lIndex + lOffset ].uiValue; ++lIndex; } } @@ -1270,18 +1224,18 @@ static void hb_gt_def_ScrollUp( int iRows, BYTE bColor, BYTE bChar ) { for( j = 0; j < iWidth; ++j ) { - s_curGT->screenBuffer[ lIndex ].c.usChar = bChar; - s_curGT->screenBuffer[ lIndex ].c.bColor = bColor; - s_curGT->screenBuffer[ lIndex ].c.bAttr = bAttr; + pGT->screenBuffer[ lIndex ].c.usChar = bChar; + pGT->screenBuffer[ lIndex ].c.bColor = bColor; + pGT->screenBuffer[ lIndex ].c.bAttr = bAttr; ++lIndex; } - s_curGT->pLines[ i ] = TRUE; + pGT->pLines[ i ] = TRUE; } - s_curGT->fRefresh = TRUE; + pGT->fRefresh = TRUE; } } -static void hb_gt_def_Box( int iTop, int iLeft, int iBottom, int iRight, +static void hb_gt_def_Box( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE * pbyFrame, BYTE bColor ) { int iMaxRow, iMaxCol, iRows, iCols, iFirst, i; @@ -1298,12 +1252,12 @@ static void hb_gt_def_Box( int iTop, int iLeft, int iBottom, int iRight, iLeft = iRight; iRight = i; } - iMaxRow = hb_gt_MaxRow(), iMaxCol = hb_gt_MaxCol(); + iMaxRow = HB_GTSELF_MAXROW( pGT ), iMaxCol = HB_GTSELF_MAXCOL( pGT ); if( iTop <= iMaxRow && iLeft <= iMaxCol && iBottom >= 0 && iRight >= 0 ) { BYTE szBox[ 10 ]; - BYTE bPadCh = hb_gt_GetClearChar(); + BYTE bPadCh = HB_GTSELF_GETCLEARCHAR( pGT ); if( pbyFrame ) { @@ -1318,9 +1272,9 @@ static void hb_gt_def_Box( int iTop, int iLeft, int iBottom, int iRight, szBox[ i ] = '\0'; if( iTop == iBottom ) - hb_gt_HorizLine( iTop, iLeft, iRight, szBox[ 1 ], bColor ); + HB_GTSELF_HORIZLINE( pGT, iTop, iLeft, iRight, szBox[ 1 ], bColor ); else if( iLeft == iRight ) - hb_gt_VertLine( iLeft, iTop, iBottom, szBox[ 3 ], bColor ); + HB_GTSELF_VERTLINE( pGT, iLeft, iTop, iBottom, szBox[ 3 ], bColor ); else { BYTE bAttr = HB_GT_ATTR_BOX; @@ -1333,11 +1287,11 @@ static void hb_gt_def_Box( int iTop, int iLeft, int iBottom, int iRight, if( iTop >= 0 ) { if( iLeft >= 0 ) - hb_gt_PutChar( iTop, iLeft, bColor, bAttr, szBox[ 0 ] ); + HB_GTSELF_PUTCHAR( pGT, iTop, iLeft, bColor, bAttr, szBox[ 0 ] ); if( iCols ) - hb_gt_Replicate( iTop, iFirst, bColor, bAttr, szBox[ 1 ], iCols ); + HB_GTSELF_REPLICATE( pGT, iTop, iFirst, bColor, bAttr, szBox[ 1 ], iCols ); if( iRight <= iMaxCol ) - hb_gt_PutChar( iTop, iFirst + iCols, bColor, bAttr, szBox[ 2 ] ); + HB_GTSELF_PUTCHAR( pGT, iTop, iFirst + iCols, bColor, bAttr, szBox[ 2 ] ); iTop++; } else @@ -1345,40 +1299,40 @@ static void hb_gt_def_Box( int iTop, int iLeft, int iBottom, int iRight, for( i = 0; i < iRows; ++i ) { if( iLeft >= 0 ) - hb_gt_PutChar( iTop + i, iLeft, bColor, bAttr, szBox[ 7 ] ); + HB_GTSELF_PUTCHAR( pGT, iTop + i, iLeft, bColor, bAttr, szBox[ 7 ] ); if( iCols && szBox[ 8 ] ) - hb_gt_Replicate( iTop + i, iFirst, bColor, bAttr, szBox[ 8 ], iCols ); + HB_GTSELF_REPLICATE( pGT, iTop + i, iFirst, bColor, bAttr, szBox[ 8 ], iCols ); if( iRight <= iMaxCol ) - hb_gt_PutChar( iTop + i, iFirst + iCols, bColor, bAttr, szBox[ 3 ] ); + HB_GTSELF_PUTCHAR( pGT, iTop + i, iFirst + iCols, bColor, bAttr, szBox[ 3 ] ); } if( iBottom <= iMaxRow ) { if( iLeft >= 0 ) - hb_gt_PutChar( iBottom, iLeft, bColor, bAttr, szBox[ 6 ] ); + HB_GTSELF_PUTCHAR( pGT, iBottom, iLeft, bColor, bAttr, szBox[ 6 ] ); if( iCols ) - hb_gt_Replicate( iBottom, iFirst, bColor, bAttr, szBox[ 5 ], iCols ); + HB_GTSELF_REPLICATE( pGT, iBottom, iFirst, bColor, bAttr, szBox[ 5 ], iCols ); if( iRight <= iMaxCol ) - hb_gt_PutChar( iBottom, iFirst + iCols, bColor, bAttr, szBox[ 4 ] ); + HB_GTSELF_PUTCHAR( pGT, iBottom, iFirst + iCols, bColor, bAttr, szBox[ 4 ] ); } } } } -static void hb_gt_def_BoxS( int iTop, int iLeft, int iBottom, int iRight, +static void hb_gt_def_BoxS( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE * pbyFrame, BYTE bColor ) { - hb_gt_Box( iTop, iLeft, iBottom, iRight, - pbyFrame ? pbyFrame : ( BYTE * ) _B_SINGLE, bColor ); + HB_GTSELF_BOX( pGT, iTop, iLeft, iBottom, iRight, + pbyFrame ? pbyFrame : ( BYTE * ) _B_SINGLE, bColor ); } -static void hb_gt_def_BoxD( int iTop, int iLeft, int iBottom, int iRight, +static void hb_gt_def_BoxD( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight, BYTE * pbyFrame, BYTE bColor ) { - hb_gt_Box( iTop, iLeft, iBottom, iRight, - pbyFrame ? pbyFrame : ( BYTE * ) _B_DOUBLE, bColor ); + HB_GTSELF_BOX( pGT, iTop, iLeft, iBottom, iRight, + pbyFrame ? pbyFrame : ( BYTE * ) _B_DOUBLE, bColor ); } -static void hb_gt_def_HorizLine( int iRow, int iLeft, int iRight, +static void hb_gt_def_HorizLine( PHB_GT pGT, int iRow, int iLeft, int iRight, BYTE bChar, BYTE bColor ) { int iLength, iCol; @@ -1394,10 +1348,10 @@ static void hb_gt_def_HorizLine( int iRow, int iLeft, int iRight, iCol = iRight; } - hb_gt_Replicate( iRow, iCol, bColor, HB_GT_ATTR_BOX, bChar, iLength ); + HB_GTSELF_REPLICATE( pGT, iRow, iCol, bColor, HB_GT_ATTR_BOX, bChar, iLength ); } -static void hb_gt_def_VertLine( int iCol, int iTop, int iBottom, +static void hb_gt_def_VertLine( PHB_GT pGT, int iCol, int iTop, int iBottom, BYTE bChar, BYTE bColor ) { int iLength, iRow; @@ -1421,53 +1375,48 @@ static void hb_gt_def_VertLine( int iCol, int iTop, int iBottom, while( --iLength >= 0 ) { - if( !hb_gt_PutChar( iRow, iCol, bColor, HB_GT_ATTR_BOX, bChar ) ) + if( !HB_GTSELF_PUTCHAR( pGT, iRow, iCol, bColor, HB_GT_ATTR_BOX, bChar ) ) break; ++iRow; } } -static BOOL hb_gt_def_SetDispCP( char * pszTermCDP, char * pszHostCDP, BOOL fBox ) +static BOOL hb_gt_def_SetDispCP( PHB_GT pGT, char * pszTermCDP, char * pszHostCDP, BOOL fBox ) { - if( s_curGT ) - { #ifndef HB_CDP_SUPPORT_OFF - if( !pszHostCDP ) - pszHostCDP = hb_cdp_page->id; - if( !pszTermCDP ) - pszTermCDP = pszHostCDP; + if( !pszHostCDP ) + pszHostCDP = hb_cdp_page->id; + if( !pszTermCDP ) + pszTermCDP = pszHostCDP; - if( pszTermCDP && pszHostCDP ) - { - s_curGT->cdpTerm = hb_cdpFind( pszTermCDP ); - s_curGT->cdpHost = hb_cdpFind( pszHostCDP ); - s_curGT->fDispTrans = s_curGT->cdpTerm && s_curGT->cdpHost && - s_curGT->cdpTerm != s_curGT->cdpHost; - return TRUE; - } -#else - HB_SYMBOL_UNUSED( pszTermCDP ); - HB_SYMBOL_UNUSED( pszHostCDP ); -#endif - HB_SYMBOL_UNUSED( fBox ); + if( pszTermCDP && pszHostCDP ) + { + pGT->cdpTerm = hb_cdpFind( pszTermCDP ); + pGT->cdpHost = hb_cdpFind( pszHostCDP ); + pGT->fDispTrans = pGT->cdpTerm && pGT->cdpHost && + pGT->cdpTerm != pGT->cdpHost; + return TRUE; } +#else + HB_SYMBOL_UNUSED( pszTermCDP ); + HB_SYMBOL_UNUSED( pszHostCDP ); +#endif + HB_SYMBOL_UNUSED( fBox ); return FALSE; } -static BOOL hb_gt_def_SetKeyCP( char * pszTermCDP, char * pszHostCDP ) +static BOOL hb_gt_def_SetKeyCP( PHB_GT pGT, char * pszTermCDP, char * pszHostCDP ) { + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( pszTermCDP ); HB_SYMBOL_UNUSED( pszHostCDP ); return FALSE; } -static BOOL hb_gt_def_Info( int iType, PHB_GT_INFO pInfo ) +static BOOL hb_gt_def_Info( PHB_GT pGT, int iType, PHB_GT_INFO pInfo ) { - if( !s_curGT ) - return FALSE; - switch ( iType ) { case GTI_ISGRAPHIC: @@ -1479,40 +1428,41 @@ static BOOL hb_gt_def_Info( int iType, PHB_GT_INFO pInfo ) break; case GTI_INPUTFD: - pInfo->pResult = hb_itemPutNInt( pInfo->pResult, s_curGT->hStdIn ); + pInfo->pResult = hb_itemPutNInt( pInfo->pResult, pGT->hStdIn ); break; case GTI_OUTPUTFD: - pInfo->pResult = hb_itemPutNInt( pInfo->pResult, s_curGT->hStdOut ); + pInfo->pResult = hb_itemPutNInt( pInfo->pResult, pGT->hStdOut ); break; case GTI_ERRORFD: - pInfo->pResult = hb_itemPutNInt( pInfo->pResult, s_curGT->hStdErr ); + pInfo->pResult = hb_itemPutNInt( pInfo->pResult, pGT->hStdErr ); break; case GTI_COMPATBUFFER: - pInfo->pResult = hb_itemPutL( pInfo->pResult, s_curGT->fVgaCell ); + pInfo->pResult = hb_itemPutL( pInfo->pResult, pGT->fVgaCell ); if( hb_itemType( pInfo->pNewVal ) & HB_IT_LOGICAL ) - s_curGT->fVgaCell = hb_itemGetL( pInfo->pNewVal ); + pGT->fVgaCell = hb_itemGetL( pInfo->pNewVal ); break; case GTI_VIEWMAXWIDTH: - pInfo->pResult = hb_itemPutNInt( pInfo->pResult, hb_gt_MaxCol() ); + pInfo->pResult = hb_itemPutNInt( pInfo->pResult, HB_GTSELF_MAXCOL( pGT ) ); break; case GTI_VIEWMAXHEIGHT: - pInfo->pResult = hb_itemPutNInt( pInfo->pResult, hb_gt_MaxRow() ); + pInfo->pResult = hb_itemPutNInt( pInfo->pResult, HB_GTSELF_MAXROW( pGT ) ); break; case GTI_NEWWIN: /* clear screen area, set default cursor shape and position */ { /* Clear screen */ - hb_gt_DispBegin(); - hb_gt_Scroll( 0, 0, hb_gt_MaxRow(), hb_gt_MaxCol(), ( BYTE ) hb_gt_GetColor(), hb_gt_GetClearChar(), 0, 0 ); - hb_gt_SetPos( 0, 0 ); - hb_gt_SetCursorStyle( SC_NORMAL ); - hb_gt_DispEnd(); - hb_gt_Flush(); + HB_GTSELF_DISPBEGIN( pGT ); + HB_GTSELF_SCROLL( pGT, 0, 0, HB_GTSELF_MAXROW( pGT ), HB_GTSELF_MAXCOL( pGT ), + HB_GTSELF_GETCOLOR( pGT ), HB_GTSELF_GETCLEARCHAR( pGT ), 0, 0 ); + HB_GTSELF_SETPOS( pGT, 0, 0 ); + HB_GTSELF_SETCURSORSTYLE( pGT, SC_NORMAL ); + HB_GTSELF_DISPEND( pGT ); + HB_GTSELF_FLUSH( pGT ); /* no break; */ } case GTI_GETWIN: /* save screen buffer, cursor shape and possition */ @@ -1523,22 +1473,22 @@ static BOOL hb_gt_def_Info( int iType, PHB_GT_INFO pInfo ) if( !pInfo->pResult ) pInfo->pResult = hb_itemNew( NULL ); hb_arrayNew( pInfo->pResult, 8 ); - hb_gt_GetPos( &iRow, &iCol ); + HB_GTSELF_GETPOS( pGT, &iRow, &iCol ); hb_itemPutNI( hb_arrayGetItemPtr( pInfo->pResult, 1 ), iRow ); hb_itemPutNI( hb_arrayGetItemPtr( pInfo->pResult, 2 ), iCol ); - hb_itemPutNI( hb_arrayGetItemPtr( pInfo->pResult, 3 ), hb_gt_GetCursorStyle() ); + hb_itemPutNI( hb_arrayGetItemPtr( pInfo->pResult, 3 ), HB_GTSELF_GETCURSORSTYLE( pGT ) ); hb_itemPutC( hb_arrayGetItemPtr( pInfo->pResult, 4 ), hb_conSetColor( NULL ) ); - iRow = hb_gt_MaxRow(); - iCol = hb_gt_MaxCol(); + iRow = HB_GTSELF_MAXROW( pGT ); + iCol = HB_GTSELF_MAXCOL( pGT ); hb_itemPutNI( hb_arrayGetItemPtr( pInfo->pResult, 5 ), iRow ); hb_itemPutNI( hb_arrayGetItemPtr( pInfo->pResult, 6 ), iCol ); - ulSize = hb_gt_RectSize( 0, 0, iRow, iCol ); + ulSize = HB_GTSELF_RECTSIZE( pGT, 0, 0, iRow, iCol ); if( ulSize ) { BYTE * pBuffer = ( BYTE * ) hb_xgrab( ulSize + 1 ); - hb_gt_Save( 0, 0, iRow, iCol, pBuffer ); + HB_GTSELF_SAVE( pGT, 0, 0, iRow, iCol, pBuffer ); hb_itemPutCPtr( hb_arrayGetItemPtr( pInfo->pResult, 7 ), ( char * ) pBuffer, ulSize ); } @@ -1547,19 +1497,19 @@ static BOOL hb_gt_def_Info( int iType, PHB_GT_INFO pInfo ) case GTI_SETWIN: /* restore screen buffer, cursor shape and possition */ if( hb_arrayLen( pInfo->pNewVal ) == 8 ) { - hb_gt_DispBegin(); + HB_GTSELF_DISPBEGIN( pGT ); if( hb_arrayGetCLen( pInfo->pNewVal, 7 ) > 0 ) { - hb_gt_Rest( 0, 0, hb_arrayGetNI( pInfo->pNewVal, 5 ), - hb_arrayGetNI( pInfo->pNewVal, 6 ), - ( BYTE * ) hb_arrayGetCPtr( pInfo->pNewVal, 7 ) ); + HB_GTSELF_REST( pGT, 0, 0, hb_arrayGetNI( pInfo->pNewVal, 5 ), + hb_arrayGetNI( pInfo->pNewVal, 6 ), + ( BYTE * ) hb_arrayGetCPtr( pInfo->pNewVal, 7 ) ); } - hb_gt_SetPos( hb_arrayGetNI( pInfo->pNewVal, 1 ), - hb_arrayGetNI( pInfo->pNewVal, 2 ) ); - hb_gt_SetCursorStyle( hb_arrayGetNI( pInfo->pNewVal, 3 ) ); + HB_GTSELF_SETPOS( pGT, hb_arrayGetNI( pInfo->pNewVal, 1 ), + hb_arrayGetNI( pInfo->pNewVal, 2 ) ); + HB_GTSELF_SETCURSORSTYLE( pGT, hb_arrayGetNI( pInfo->pNewVal, 3 ) ); hb_conSetColor( hb_arrayGetCPtr( pInfo->pNewVal, 4 ) ); - hb_gt_DispEnd(); - hb_gt_Flush(); + HB_GTSELF_DISPEND( pGT ); + HB_GTSELF_FLUSH( pGT ); } break; @@ -1590,7 +1540,7 @@ static BOOL hb_gt_def_Info( int iType, PHB_GT_INFO pInfo ) return TRUE; } -static int hb_gt_def_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, +static int hb_gt_def_Alert( PHB_GT pGT, PHB_ITEM pMessage, PHB_ITEM pOptions, int iClrNorm, int iClrHigh, double dDelay ) { int iOptions = ( int ) hb_arrayLen( pOptions ); @@ -1608,18 +1558,18 @@ static int hb_gt_def_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, gtInfo.pNewVal = gtInfo.pResult = NULL; - hb_gt_Info( GTI_FULLSCREEN, >Info ); + HB_GTSELF_INFO( pGT, GTI_FULLSCREEN, >Info ); if( gtInfo.pResult ) { fScreen = hb_itemGetL( gtInfo.pResult ); } - hb_gt_Info( GTI_KBDSUPPORT, >Info ); + HB_GTSELF_INFO( pGT, GTI_KBDSUPPORT, >Info ); if( gtInfo.pResult ) { fKeyBoard = hb_itemGetL( gtInfo.pResult ); hb_itemRelease( gtInfo.pResult ); } - hb_gt_GetSize( &iRows, &iCols ); + HB_GTSELF_GETSIZE( pGT, &iRows, &iCols ); if( iCols <= 4 || iRows <= 4 ) fScreen = FALSE; @@ -1734,20 +1684,20 @@ static int hb_gt_def_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, iClrNorm = 79; if( iClrHigh == 0 ) iClrHigh = 31; - iDspCount = hb_gt_DispCount(); + iDspCount = HB_GTSELF_DISPCOUNT( pGT ); if( iDspCount == 0 ) - hb_gt_DispBegin(); - hb_gt_GetPos( &iRow, &iCol ); - iStyle = hb_gt_GetCursorStyle(); - hb_gt_SetCursorStyle( SC_NONE ); - ulLen = hb_gt_RectSize( iTop, iLeft, iBottom, iRight ); + HB_GTSELF_DISPBEGIN( pGT ); + HB_GTSELF_GETPOS( pGT, &iRow, &iCol ); + iStyle = HB_GTSELF_GETCURSORSTYLE( pGT ); + HB_GTSELF_SETCURSORSTYLE( pGT, SC_NONE ); + ulLen = HB_GTSELF_RECTSIZE( pGT, iTop, iLeft, iBottom, iRight ); if( ulLen ) { pBuffer = ( BYTE * ) hb_xgrab( ulLen ); - hb_gt_Save( iTop, iLeft, iBottom, iRight, pBuffer ); + HB_GTSELF_SAVE( pGT, iTop, iLeft, iBottom, iRight, pBuffer ); } - hb_gt_BoxS( iTop, iLeft, iBottom, iRight, NULL, iClrNorm ); - hb_gt_Box( iTop + 1, iLeft + 1, iBottom - 1, iRight - 1, ( BYTE * ) " ", iClrNorm ); + HB_GTSELF_BOXS( pGT, iTop, iLeft, iBottom, iRight, NULL, iClrNorm ); + HB_GTSELF_BOXS( pGT, iTop + 1, iLeft + 1, iBottom - 1, iRight - 1, ( BYTE * ) " ", iClrNorm ); ulLast = 0; i = iTop + 1; for( ul = 0; ul < ulDst; ++ul ) @@ -1759,8 +1709,8 @@ static int hb_gt_def_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, ulLen = ul - ulLast; if( ulLen > ulWidth ) ulLen = ulWidth; - hb_gt_PutText( i, iLeft + ( ( ulWidth - ulLen + 1 ) >> 1 ) + 2, - iClrNorm, ( BYTE * ) szMsgDsp + ulLast, ulLen ); + HB_GTSELF_PUTTEXT( pGT, i, iLeft + ( ( ulWidth - ulLen + 1 ) >> 1 ) + 2, + iClrNorm, ( BYTE * ) szMsgDsp + ulLast, ulLen ); } ulLast = ul + 1; if( ++i >= iBottom - 1 ) @@ -1772,30 +1722,30 @@ static int hb_gt_def_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, ulLen = ul - ulLast; if( ulLen > ulWidth ) ulLen = ulWidth; - hb_gt_PutText( i, iLeft + ( ( ulWidth - ulLen + 1 ) >> 1 ) + 2, - iClrNorm, ( BYTE * ) szMsgDsp + ulLast, ulLen ); + HB_GTSELF_PUTTEXT( pGT, i, iLeft + ( ( ulWidth - ulLen + 1 ) >> 1 ) + 2, + iClrNorm, ( BYTE * ) szMsgDsp + ulLast, ulLen ); } iPos = 1; while( iRet == 0 ) { - hb_gt_DispBegin(); + HB_GTSELF_DISPBEGIN( pGT ); iMnuCol = iLeft + ( ( ulWidth - ulCurrWidth ) >> 1 ) + 3; for( i = 1; i <= iOptions; ++i ) { iClr = i == iPos ? iClrHigh : iClrNorm; ulLen = hb_arrayGetCLen( pOptions, i ); - hb_gt_PutText( iBottom - 1, iMnuCol, iClr, ( BYTE * ) " ", 1 ); - hb_gt_PutText( iBottom - 1, iMnuCol + 1, iClr, - ( BYTE * ) hb_arrayGetCPtr( pOptions, i ), ulLen ); - hb_gt_PutText( iBottom - 1, iMnuCol + 1 + ulLen, iClr, ( BYTE * ) " ", 1 ); + HB_GTSELF_PUTTEXT( pGT, iBottom - 1, iMnuCol, iClr, ( BYTE * ) " ", 1 ); + HB_GTSELF_PUTTEXT( pGT, iBottom - 1, iMnuCol + 1, iClr, + ( BYTE * ) hb_arrayGetCPtr( pOptions, i ), ulLen ); + HB_GTSELF_PUTTEXT( pGT, iBottom - 1, iMnuCol + 1 + ulLen, iClr, ( BYTE * ) " ", 1 ); iMnuCol += ulLen + 4; } - while( hb_gt_DispCount() ) - hb_gt_DispEnd(); - hb_gt_Refresh(); + while( HB_GTSELF_DISPCOUNT( pGT ) ) + HB_GTSELF_DISPEND( pGT ); + HB_GTSELF_REFRESH( pGT ); - iKey = fKeyBoard ? hb_inkey( TRUE, dDelay, INKEY_ALL ) : 0; + iKey = fKeyBoard ? HB_GTSELF_INKEYGET( pGT, TRUE, dDelay, INKEY_ALL ) : 0; if( iKey == K_ESC ) break; @@ -1819,7 +1769,7 @@ static int hb_gt_def_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, else if( iKey == K_LBUTTONDOWN ) { int iMRow, iMCol; - hb_mouse_GetPos( &iMRow, &iMCol ); + HB_GTSELF_MOUSEGETPOS( pGT, &iMRow, &iMCol ); if( iMRow == iBottom - 1 ) { iMnuCol = iLeft + ( ( ulWidth - ulCurrWidth ) >> 1 ) + 4; @@ -1854,14 +1804,14 @@ static int hb_gt_def_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, hb_xfree( szMsgDsp ); if( pBuffer ) { - hb_gt_Rest( iTop, iLeft, iBottom, iRight, pBuffer ); + HB_GTSELF_REST( pGT, iTop, iLeft, iBottom, iRight, pBuffer ); hb_xfree( pBuffer ); } - hb_gt_SetPos( iRow, iCol ); - hb_gt_SetCursorStyle( iStyle ); - hb_gt_Refresh(); - while( hb_gt_DispCount() < iDspCount ) - hb_gt_DispBegin(); + HB_GTSELF_SETPOS( pGT, iRow, iCol ); + HB_GTSELF_SETCURSORSTYLE( pGT, iStyle ); + HB_GTSELF_REFRESH( pGT ); + while( HB_GTSELF_DISPCOUNT( pGT ) < iDspCount ) + HB_GTSELF_DISPBEGIN( pGT ); } else { @@ -1873,25 +1823,25 @@ static int hb_gt_def_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, if( szMessage[ ul ] == '\n' ) { if( ul > ulStart ) - hb_gt_WriteCon( ( BYTE * ) szMessage + ulStart, ul - ulStart ); - hb_gt_WriteCon( ( BYTE * ) szEol, strlen( szEol ) ); + HB_GTSELF_WRITECON( pGT, ( BYTE * ) szMessage + ulStart, ul - ulStart ); + HB_GTSELF_WRITECON( pGT, ( BYTE * ) szEol, strlen( szEol ) ); ulStart = ul + 1; } } if( ul > ulStart ) - hb_gt_WriteCon( ( BYTE * ) szMessage + ulStart, ul - ulStart ); - hb_gt_WriteCon( ( BYTE * ) " (", 2 ); + HB_GTSELF_WRITECON( pGT, ( BYTE * ) szMessage + ulStart, ul - ulStart ); + HB_GTSELF_WRITECON( pGT, ( BYTE * ) " (", 2 ); for( i = 1; i <= iOptions; ++i ) { if( i > 1 ) - hb_gt_WriteCon( ( BYTE * ) ", ", 2 ); - hb_gt_WriteCon( ( BYTE * ) hb_arrayGetCPtr( pOptions, i ), - hb_arrayGetCLen( pOptions, i ) ); + HB_GTSELF_WRITECON( pGT, ( BYTE * ) ", ", 2 ); + HB_GTSELF_WRITECON( pGT, ( BYTE * ) hb_arrayGetCPtr( pOptions, i ), + hb_arrayGetCLen( pOptions, i ) ); } - hb_gt_WriteCon( ( BYTE * ) ") ", 2 ); + HB_GTSELF_WRITECON( pGT, ( BYTE * ) ") ", 2 ); while( iRet == 0 ) { - iKey = fKeyBoard ? hb_inkey( TRUE, dDelay, INKEY_ALL ) : 0; + iKey = fKeyBoard ? HB_GTSELF_INKEYGET( pGT, TRUE, dDelay, INKEY_ALL ) : 0; if( iKey == 0 ) iRet = 1; else if( iKey == K_ESC ) @@ -1915,7 +1865,7 @@ static int hb_gt_def_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, char szVal[2]; szVal[ 0 ] = ( char ) iKey; szVal[ 1 ] = '\0'; - hb_gt_WriteCon( ( BYTE * ) szVal, 1 ); + HB_GTSELF_WRITECON( pGT, ( BYTE * ) szVal, 1 ); } } } @@ -1923,91 +1873,88 @@ static int hb_gt_def_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, return iRet; } -static int hb_gt_def_SetFlag( int iType, int iNewValue ) +static int hb_gt_def_SetFlag( PHB_GT pGT, int iType, int iNewValue ) { int iPrevValue = 0; - if( !s_curGT ) - return 0; - switch ( iType ) { case GTI_COMPATBUFFER: - iPrevValue = s_curGT->fVgaCell; - s_curGT->fVgaCell = iNewValue != 0; + iPrevValue = pGT->fVgaCell; + pGT->fVgaCell = iNewValue != 0; break; case GTI_STDOUTCON: - iPrevValue = s_curGT->fStdOutCon; - s_curGT->fStdOutCon = iNewValue != 0; + iPrevValue = pGT->fStdOutCon; + pGT->fStdOutCon = iNewValue != 0; break; case GTI_STDERRCON: - iPrevValue = s_curGT->fStdErrCon; - s_curGT->fStdErrCon = iNewValue != 0; + iPrevValue = pGT->fStdErrCon; + pGT->fStdErrCon = iNewValue != 0; break; } return iPrevValue; } -static BOOL hb_gt_def_SetMode( int iRows, int iCols ) +static BOOL hb_gt_def_SetMode( PHB_GT pGT, int iRows, int iCols ) { - return hb_gt_Resize( iRows, iCols ); + return HB_GTSELF_RESIZE( pGT, iRows, iCols ); } -static BOOL hb_gt_def_Resize( int iRows, int iCols ) +static BOOL hb_gt_def_Resize( PHB_GT pGT, int iRows, int iCols ) { - if( iRows > 0 && iCols > 0 && s_curGT ) + if( iRows > 0 && iCols > 0 && pGT->screenBuffer ) { - if( s_curGT->iHeight != iRows || s_curGT->iWidth != iCols ) + if( pGT->iHeight != iRows || pGT->iWidth != iCols ) { BYTE * pBuffer = NULL; ULONG ulLen = ( ULONG ) iRows * iCols, ulIndex; ULONG ulSize; int i; - ulSize = hb_gt_RectSize( 0, 0, iRows - 1, iCols - 1 ); + ulSize = HB_GTSELF_RECTSIZE( pGT, 0, 0, iRows - 1, iCols - 1 ); if( ulSize ) { pBuffer = ( BYTE * ) hb_xgrab( ulSize ); - hb_gt_Save( 0, 0, iRows - 1, iCols - 1, pBuffer ); + HB_GTSELF_SAVE( pGT, 0, 0, iRows - 1, iCols - 1, pBuffer ); } - s_curGT->screenBuffer = - ( PHB_SCREENCELL ) hb_xrealloc( s_curGT->screenBuffer, + pGT->screenBuffer = + ( PHB_SCREENCELL ) hb_xrealloc( pGT->screenBuffer, sizeof( HB_SCREENCELL ) * ulLen ); - s_curGT->prevBuffer = - ( PHB_SCREENCELL ) hb_xrealloc( s_curGT->prevBuffer, + pGT->prevBuffer = + ( PHB_SCREENCELL ) hb_xrealloc( pGT->prevBuffer, sizeof( HB_SCREENCELL ) * ulLen ); - s_curGT->pLines = ( BOOL * ) hb_xrealloc( s_curGT->pLines, + pGT->pLines = ( BOOL * ) hb_xrealloc( pGT->pLines, sizeof( BOOL ) * iRows ); - memset( s_curGT->screenBuffer, 0, sizeof( HB_SCREENCELL ) * ulLen ); - memset( s_curGT->prevBuffer, 0, sizeof( HB_SCREENCELL ) * ulLen ); + memset( pGT->screenBuffer, 0, sizeof( HB_SCREENCELL ) * ulLen ); + memset( pGT->prevBuffer, 0, sizeof( HB_SCREENCELL ) * ulLen ); for( i = 0; i < iRows; ++i ) - s_curGT->pLines[ i ] = TRUE; + pGT->pLines[ i ] = TRUE; for( ulIndex = 0; ulIndex < ulLen; ++ulIndex ) { - s_curGT->screenBuffer[ ulIndex ].c.usChar = hb_gt_GetClearChar(); - s_curGT->screenBuffer[ ulIndex ].c.bColor = hb_gt_GetClearColor(); - s_curGT->screenBuffer[ ulIndex ].c.bAttr = 0x00; - s_curGT->prevBuffer[ ulIndex ].c.bAttr = HB_GT_ATTR_REFRESH; + pGT->screenBuffer[ ulIndex ].c.usChar = HB_GTSELF_GETCLEARCHAR( pGT ); + pGT->screenBuffer[ ulIndex ].c.bColor = HB_GTSELF_GETCLEARCOLOR( pGT ); + pGT->screenBuffer[ ulIndex ].c.bAttr = 0x00; + pGT->prevBuffer[ ulIndex ].c.bAttr = HB_GT_ATTR_REFRESH; } - s_curGT->iHeight = iRows; - s_curGT->iWidth = iCols; + pGT->iHeight = iRows; + pGT->iWidth = iCols; - if( s_curGT->iRow >= s_curGT->iHeight ) - s_curGT->iRow = s_curGT->iHeight - 1; - if( s_curGT->iCol >= s_curGT->iWidth ) - s_curGT->iCol = s_curGT->iWidth - 1; + if( pGT->iRow >= pGT->iHeight ) + pGT->iRow = pGT->iHeight - 1; + if( pGT->iCol >= pGT->iWidth ) + pGT->iCol = pGT->iWidth - 1; - s_curGT->fRefresh = TRUE; + pGT->fRefresh = TRUE; if( ulSize ) { - hb_gt_Rest( 0, 0, iRows - 1, iCols - 1, pBuffer ); + HB_GTSELF_REST( pGT, 0, 0, iRows - 1, iCols - 1, pBuffer ); hb_xfree( pBuffer ); } } @@ -2018,186 +1965,168 @@ static BOOL hb_gt_def_Resize( int iRows, int iCols ) return FALSE; } -static void hb_gt_def_GetSize( int * piRows, int * piCols ) +static void hb_gt_def_GetSize( PHB_GT pGT, int * piRows, int * piCols ) { - if( s_curGT ) - { - *piRows = s_curGT->iHeight; - *piCols = s_curGT->iWidth; - } - else - { - *piRows = 25; - *piCols = 80; - } + *piRows = pGT->iHeight; + *piCols = pGT->iWidth; } -static void hb_gt_def_SemiCold( void ) +static void hb_gt_def_SemiCold( PHB_GT pGT ) { - if( s_curGT ) - { - int i; - for( i = 0; i < s_curGT->iHeight; ++i ) - s_curGT->pLines[ i ] = FALSE; - s_curGT->fRefresh = FALSE; - } + int i; + for( i = 0; i < pGT->iHeight; ++i ) + pGT->pLines[ i ] = FALSE; + pGT->fRefresh = FALSE; } -static void hb_gt_def_ColdArea( int iTop, int iLeft, int iBottom, int iRight ) +static void hb_gt_def_ColdArea( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight ) { - if( s_curGT ) - { - long lIndex; - int i; + long lIndex; + int i; - if( iTop > iBottom ) + if( iTop > iBottom ) + { + i = iTop; + iTop = iBottom; + iBottom = i; + } + if( iLeft > iRight ) + { + i = iLeft; + iLeft = iRight; + iRight = i; + } + while( iTop <= iBottom ) + { + for( i = iLeft; i <= iRight; ++i ) { - i = iTop; - iTop = iBottom; - iBottom = i; - } - if( iLeft > iRight ) - { - i = iLeft; - iLeft = iRight; - iRight = i; - } - while( iTop <= iBottom ) - { - for( i = iLeft; i <= iRight; ++i ) + if( HB_GTSELF_CHECKPOS( pGT, iTop, i, &lIndex ) ) { - if( hb_gt_CheckPos( iTop, i, &lIndex ) ) - { - s_curGT->prevBuffer[ lIndex ].uiValue = - ( s_curGT->screenBuffer[ lIndex ].uiValue &= - ~HB_GT_ATTR_REFRESH ); - } + pGT->prevBuffer[ lIndex ].uiValue = + ( pGT->screenBuffer[ lIndex ].uiValue &= ~HB_GT_ATTR_REFRESH ); } - if( iLeft == 0 && iRight == s_curGT->iWidth - 1 ) - s_curGT->pLines[ iTop ] = FALSE; - ++iTop; } + if( iLeft == 0 && iRight == pGT->iWidth - 1 ) + pGT->pLines[ iTop ] = FALSE; + ++iTop; } } -static void hb_gt_def_ExposeArea( int iTop, int iLeft, int iBottom, int iRight ) +static void hb_gt_def_ExposeArea( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight ) { - if( s_curGT ) - { - long lIndex; - int i; + long lIndex; + int i; - if( iTop > iBottom ) + if( iTop > iBottom ) + { + i = iTop; + iTop = iBottom; + iBottom = i; + } + if( iLeft > iRight ) + { + i = iLeft; + iLeft = iRight; + iRight = i; + } + while( iTop <= iBottom ) + { + for( i = iLeft; i <= iRight; ++i ) { - i = iTop; - iTop = iBottom; - iBottom = i; - } - if( iLeft > iRight ) - { - i = iLeft; - iLeft = iRight; - iRight = i; - } - while( iTop <= iBottom ) - { - for( i = iLeft; i <= iRight; ++i ) + if( HB_GTSELF_CHECKPOS( pGT, iTop, i, &lIndex ) ) { - if( hb_gt_CheckPos( iTop, i, &lIndex ) ) - { - s_curGT->prevBuffer[ lIndex ].c.bAttr = HB_GT_ATTR_REFRESH; - s_curGT->pLines[ iTop ] = TRUE; - s_curGT->fRefresh = TRUE; - } + pGT->prevBuffer[ lIndex ].c.bAttr = HB_GT_ATTR_REFRESH; + pGT->pLines[ iTop ] = TRUE; + pGT->fRefresh = TRUE; } - ++iTop; } + ++iTop; } } -static void hb_gt_def_TouchCell( int iRow, int iCol ) +static void hb_gt_def_TouchCell( PHB_GT pGT, int iRow, int iCol ) { - if( s_curGT ) + long lIndex; + + if( HB_GTSELF_CHECKPOS( pGT, iRow, iCol, &lIndex ) ) { - long lIndex; - - if( hb_gt_CheckPos( iRow, iCol, &lIndex ) ) - { - s_curGT->prevBuffer[ lIndex ].c.bAttr = HB_GT_ATTR_REFRESH; - s_curGT->pLines[ iRow ] = TRUE; - s_curGT->fRefresh = TRUE; - } + pGT->prevBuffer[ lIndex ].c.bAttr = HB_GT_ATTR_REFRESH; + pGT->pLines[ iRow ] = TRUE; + pGT->fRefresh = TRUE; } } -static void hb_gt_def_Redraw( int iRow, int iCol, int iSize ) +static void hb_gt_def_Redraw( PHB_GT pGT, int iRow, int iCol, int iSize ) { + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( iRow ); HB_SYMBOL_UNUSED( iCol ); HB_SYMBOL_UNUSED( iSize ); } -static void hb_gt_def_Refresh( void ) +static void hb_gt_def_Refresh( PHB_GT pGT ) { - if( s_curGT && s_curGT->fRefresh ) + if( pGT->fRefresh ) { int i, l, r; long lIndex; - for( i = 0; i < s_curGT->iHeight; ++i ) + for( i = 0; i < pGT->iHeight; ++i ) { - if( s_curGT->pLines[ i ] ) + if( pGT->pLines[ i ] ) { - lIndex = ( long ) i * s_curGT->iWidth; - for( l = 0; l < s_curGT->iWidth; ++l, ++lIndex ) + lIndex = ( long ) i * pGT->iWidth; + for( l = 0; l < pGT->iWidth; ++l, ++lIndex ) { - if( s_curGT->prevBuffer[ lIndex ].uiValue != - s_curGT->screenBuffer[ lIndex ].uiValue ) + if( pGT->prevBuffer[ lIndex ].uiValue != + pGT->screenBuffer[ lIndex ].uiValue ) break; } - if( l < s_curGT->iWidth ) + if( l < pGT->iWidth ) { - lIndex = ( long ) ( i + 1 ) * s_curGT->iWidth - 1; - for( r = s_curGT->iWidth - 1; r > l; --r, --lIndex ) + lIndex = ( long ) ( i + 1 ) * pGT->iWidth - 1; + for( r = pGT->iWidth - 1; r > l; --r, --lIndex ) { - if( s_curGT->prevBuffer[ lIndex ].uiValue != - s_curGT->screenBuffer[ lIndex ].uiValue ) + if( pGT->prevBuffer[ lIndex ].uiValue != + pGT->screenBuffer[ lIndex ].uiValue ) break; } - hb_gt_Redraw( i, l, r - l + 1 ); - lIndex = ( long ) i * s_curGT->iWidth + l; + HB_GTSELF_REDRAW( pGT, i, l, r - l + 1 ); + lIndex = ( long ) i * pGT->iWidth + l; do { - s_curGT->prevBuffer[ lIndex ].uiValue = - s_curGT->screenBuffer[ lIndex ].uiValue; + pGT->prevBuffer[ lIndex ].uiValue = + pGT->screenBuffer[ lIndex ].uiValue; ++lIndex; } while( ++l <= r ); } - s_curGT->pLines[ i ] = FALSE; + pGT->pLines[ i ] = FALSE; } } - s_curGT->fRefresh = FALSE; + pGT->fRefresh = FALSE; } } -static void hb_gt_def_Flush( void ) +static void hb_gt_def_Flush( PHB_GT pGT ) { - if( hb_gt_DispCount() == 0 ) - hb_gt_Refresh(); + if( HB_GTSELF_DISPCOUNT( pGT ) == 0 ) + HB_GTSELF_REFRESH( pGT ); } -static int hb_gt_def_ReadKey( int iEventMask ) +static int hb_gt_def_ReadKey( PHB_GT pGT, int iEventMask ) { - return hb_mouse_ReadKey( iEventMask ); + return HB_GTSELF_MOUSEREADKEY( pGT, iEventMask ); } /* helper internal function */ -static int hb_gt_def_InkeyFilter( int iKey, int iEventMask ) +static int hb_gt_def_InkeyFilter( PHB_GT pGT, int iKey, int iEventMask ) { int iMask; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyFilter(%d,%d)", iKey, iEventMask)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyFilter(%p,%d,%d)", pGT, iKey, iEventMask)); + + HB_SYMBOL_UNUSED( pGT ); switch( iKey ) { @@ -2243,97 +2172,90 @@ static int hb_gt_def_InkeyFilter( int iKey, int iEventMask ) } /* helper internal function: drop the next key in keyboard buffer */ -static void hb_gt_def_InkeyPop( void ) +static void hb_gt_def_InkeyPop( PHB_GT pGT ) { - if( s_curGT ) + if( pGT->StrBuffer ) { - if( s_curGT->StrBuffer ) + if( ++pGT->StrBufferPos >= pGT->StrBufferSize ) { - if( ++s_curGT->StrBufferPos >= s_curGT->StrBufferSize ) - { - hb_xfree( s_curGT->StrBuffer ); - s_curGT->StrBuffer = NULL; - } - } - else if( s_curGT->inkeyHead != s_curGT->inkeyTail ) - { - if( ++s_curGT->inkeyTail >= s_curGT->inkeyBufferSize ) - s_curGT->inkeyTail = 0; + hb_xfree( pGT->StrBuffer ); + pGT->StrBuffer = NULL; } } + else if( pGT->inkeyHead != pGT->inkeyTail ) + { + if( ++pGT->inkeyTail >= pGT->inkeyBufferSize ) + pGT->inkeyTail = 0; + } } /* Put the key into keyboard buffer */ -static void hb_gt_def_InkeyPut( int iKey ) +static void hb_gt_def_InkeyPut( PHB_GT pGT, int iKey ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyPut(%d)", iKey)); + int iHead; - if( s_curGT ) + HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyPut(%p,%d)", pGT, iKey)); + + iHead = pGT->inkeyHead; + + if( iKey == K_MOUSEMOVE ) { - int iHead = s_curGT->inkeyHead; - - if( iKey == K_MOUSEMOVE ) - { - /* - * Clipper does not store in buffer repeated mouse movement - * IMHO it's good idea to reduce unnecessary inkey buffer - * overloading so I also implemented it, [druzus] - */ - if( s_curGT->iLastPut == iKey && s_curGT->inkeyHead != s_curGT->inkeyTail ) - return; - } - /* - * When the buffer is full new event overwrite the last one - * in the buffer - it's Clipper behavior, [druzus] + * Clipper does not store in buffer repeated mouse movement + * IMHO it's good idea to reduce unnecessary inkey buffer + * overloading so I also implemented it, [druzus] */ - s_curGT->inkeyBuffer[ iHead++ ] = s_curGT->iLastPut = iKey; - if( iHead >= s_curGT->inkeyBufferSize ) - iHead = 0; - - if( iHead != s_curGT->inkeyTail ) - s_curGT->inkeyHead = iHead; + if( pGT->iLastPut == iKey && pGT->inkeyHead != pGT->inkeyTail ) + return; } + + /* + * When the buffer is full new event overwrite the last one + * in the buffer - it's Clipper behavior, [druzus] + */ + pGT->inkeyBuffer[ iHead++ ] = pGT->iLastPut = iKey; + if( iHead >= pGT->inkeyBufferSize ) + iHead = 0; + + if( iHead != pGT->inkeyTail ) + pGT->inkeyHead = iHead; } /* helper internal function */ -static BOOL hb_gt_def_InkeyNextCheck( int iEventMask, int * iKey ) +static BOOL hb_gt_def_InkeyNextCheck( PHB_GT pGT, int iEventMask, int * iKey ) { - HB_TRACE( HB_TR_DEBUG, ("hb_gt_def_InkeyNextCheck(%p)", iKey) ); + HB_TRACE( HB_TR_DEBUG, ("hb_gt_def_InkeyNextCheck(%p,%d)", pGT, iKey) ); - if( s_curGT ) + if( pGT->StrBuffer ) { - if( s_curGT->StrBuffer ) - { - *iKey = s_curGT->StrBuffer[ s_curGT->StrBufferPos ]; - } - else if( s_curGT->inkeyHead != s_curGT->inkeyTail ) - { - *iKey = hb_gt_def_InkeyFilter( s_curGT->inkeyBuffer[ s_curGT->inkeyTail ], iEventMask ); - } - else - { - return FALSE; - } + *iKey = pGT->StrBuffer[ pGT->StrBufferPos ]; + } + else if( pGT->inkeyHead != pGT->inkeyTail ) + { + *iKey = hb_gt_def_InkeyFilter( pGT, pGT->inkeyBuffer[ pGT->inkeyTail ], iEventMask ); + } + else + { + return FALSE; + } - if( *iKey == 0 ) - { - hb_gt_def_InkeyPop(); - return FALSE; - } + if( *iKey == 0 ) + { + hb_gt_def_InkeyPop( pGT ); + return FALSE; } return TRUE; } /* helper internal function */ -static void hb_gt_def_InkeyPollDo( void ) +static void hb_gt_def_InkeyPollDo( PHB_GT pGT ) { int iKey; - HB_TRACE( HB_TR_DEBUG, ("hb_gt_def_InkeyPollDo()") ); + HB_TRACE( HB_TR_DEBUG, ("hb_gt_def_InkeyPollDo(%p)", pGT) ); - iKey = hb_gt_ReadKey( INKEY_ALL ); + iKey = HB_GTSELF_READKEY( pGT, INKEY_ALL ); if( iKey ) { @@ -2354,14 +2276,14 @@ static void hb_gt_def_InkeyPollDo( void ) return; } } - hb_inkey_Put( iKey ); + HB_GTSELF_INKEYPUT( pGT, iKey ); } } /* Poll the console keyboard to stuff the Harbour buffer */ -static void hb_gt_def_InkeyPoll( void ) +static void hb_gt_def_InkeyPoll( PHB_GT pGT ) { - HB_TRACE( HB_TR_DEBUG, ("hb_gt_def_InkeyPoll()") ); + HB_TRACE( HB_TR_DEBUG, ("hb_gt_def_InkeyPoll(%p)", pGT) ); /* * Clipper 5.3 always poll events without respecting @@ -2372,268 +2294,260 @@ static void hb_gt_def_InkeyPoll( void ) */ if( hb_set.HB_SET_TYPEAHEAD ) { - hb_gt_def_InkeyPollDo(); + hb_gt_def_InkeyPollDo( pGT ); } } /* Return the next key without extracting it */ -static int hb_gt_def_InkeyNext( int iEventMask ) +static int hb_gt_def_InkeyNext( PHB_GT pGT, int iEventMask ) { int iKey = 0; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyNext(%d)", iEventMask)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyNext(%p,%d)", pGT, iEventMask)); - hb_inkey_Poll(); - hb_gt_def_InkeyNextCheck( iEventMask, &iKey ); + HB_GTSELF_INKEYPOLL( pGT ); + hb_gt_def_InkeyNextCheck( pGT, iEventMask, &iKey ); return iKey; } /* Wait for keyboard input */ -static int hb_gt_def_InkeyGet( BOOL fWait, double dSeconds, int iEventMask ) +static int hb_gt_def_InkeyGet( PHB_GT pGT, BOOL fWait, double dSeconds, int iEventMask ) { HB_ULONG end_timer; BOOL fPop; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyGet(%d, %f, %d)", (int) fWait, dSeconds, iEventMask)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyGet(%p,%d,%f,%d)", pGT, (int) fWait, dSeconds, iEventMask)); - if( s_curGT ) + /* Wait forever ?, Use fixed value 100 for strict Clipper compatibility */ + if( fWait && dSeconds * 100 >= 1 ) + end_timer = hb_dateMilliSeconds() + ( HB_ULONG ) ( dSeconds * 1000 ); + else + end_timer = 0; + + do { - /* Wait forever ?, Use fixed value 100 for strict Clipper compatibility */ - if( fWait && dSeconds * 100 >= 1 ) - end_timer = hb_dateMilliSeconds() + ( HB_ULONG ) ( dSeconds * 1000 ); - else - end_timer = 0; - - do - { - hb_gt_def_InkeyPollDo(); - fPop = hb_gt_def_InkeyNextCheck( iEventMask, &s_curGT->inkeyLast ); - - if( fPop ) - break; - - /* immediately break if a VM request is pending. */ - if( !fWait || hb_vmRequestQuery() != 0 ) - return 0; - - hb_idleState(); - } - while( end_timer == 0 || end_timer > hb_dateMilliSeconds() ); - - hb_idleReset(); + hb_gt_def_InkeyPollDo( pGT ); + fPop = hb_gt_def_InkeyNextCheck( pGT, iEventMask, &pGT->inkeyLast ); if( fPop ) - { - hb_gt_def_InkeyPop(); - return s_curGT->inkeyLast; - } + break; + + /* immediately break if a VM request is pending. */ + if( !fWait || hb_vmRequestQuery() != 0 ) + return 0; + + hb_idleState(); + } + while( end_timer == 0 || end_timer > hb_dateMilliSeconds() ); + + hb_idleReset(); + + if( fPop ) + { + hb_gt_def_InkeyPop( pGT ); + return pGT->inkeyLast; } return 0; } /* Return the value of the last key that was extracted */ -static int hb_gt_def_InkeyLast( int iEventMask ) +static int hb_gt_def_InkeyLast( PHB_GT pGT, int iEventMask ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyLast(%d)", iEventMask)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyLast(%p,%d)", pGT, iEventMask)); - hb_inkey_Poll(); + HB_GTSELF_INKEYPOLL( pGT ); - return s_curGT ? hb_gt_def_InkeyFilter( s_curGT->inkeyLast, iEventMask ) : 0; + return hb_gt_def_InkeyFilter( pGT, pGT->inkeyLast, iEventMask ); } /* Set LastKey() value and return previous value */ -static int hb_gt_def_InkeySetLast( int iKey ) +static int hb_gt_def_InkeySetLast( PHB_GT pGT, int iKey ) { - int iLast = 0; - HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeySetLast(%d)", iKey)); + int iLast; - if( s_curGT ) - { - iLast = s_curGT->inkeyLast; - s_curGT->inkeyLast = iKey; - } + HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeySetLast(%p,%d)", pGT, iKey)); + + iLast = pGT->inkeyLast; + pGT->inkeyLast = iKey; return iLast; } /* Set text into inkey buffer */ -static void hb_gt_def_InkeySetText( const char * szText, ULONG ulLen ) +static void hb_gt_def_InkeySetText( PHB_GT pGT, const char * szText, ULONG ulLen ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeySetText(%s,%lu)", szText, ulLen)); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeySetText(%p,%s,%lu)", pGT, szText, ulLen)); - if( s_curGT ) + if( pGT->StrBuffer ) { - if( s_curGT->StrBuffer ) - { - hb_xfree( s_curGT->StrBuffer ); - s_curGT->StrBuffer = NULL; - } + hb_xfree( pGT->StrBuffer ); + pGT->StrBuffer = NULL; + } - if( szText && ulLen ) - { - s_curGT->StrBuffer = ( BYTE * ) hb_xgrab( ulLen ); - memcpy( s_curGT->StrBuffer, szText, ulLen ); - s_curGT->StrBufferSize = ulLen; - s_curGT->StrBufferPos = 0; - } + if( szText && ulLen ) + { + pGT->StrBuffer = ( BYTE * ) hb_xgrab( ulLen ); + memcpy( pGT->StrBuffer, szText, ulLen ); + pGT->StrBufferSize = ulLen; + pGT->StrBufferPos = 0; } } /* Reset the keyboard buffer */ -static void hb_gt_def_InkeyReset( void ) +static void hb_gt_def_InkeyReset( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyReset()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyReset(%p)", pGT)); - if( s_curGT ) + if( pGT->StrBuffer ) { - if( s_curGT->StrBuffer ) + hb_xfree( pGT->StrBuffer ); + pGT->StrBuffer = NULL; + } + + pGT->inkeyHead = 0; + pGT->inkeyTail = 0; + + if( hb_set.HB_SET_TYPEAHEAD != pGT->inkeyBufferSize ) + { + if( pGT->inkeyBufferSize > HB_DEFAULT_INKEY_BUFSIZE ) + hb_xfree( pGT->inkeyBuffer ); + + if( hb_set.HB_SET_TYPEAHEAD > HB_DEFAULT_INKEY_BUFSIZE ) { - hb_xfree( s_curGT->StrBuffer ); - s_curGT->StrBuffer = NULL; + pGT->inkeyBufferSize = hb_set.HB_SET_TYPEAHEAD; + pGT->inkeyBuffer = ( int * ) hb_xgrab( pGT->inkeyBufferSize * sizeof( int ) ); } - - s_curGT->inkeyHead = 0; - s_curGT->inkeyTail = 0; - - if( hb_set.HB_SET_TYPEAHEAD != s_curGT->inkeyBufferSize ) + else { - if( s_curGT->inkeyBufferSize > HB_DEFAULT_INKEY_BUFSIZE ) - hb_xfree( s_curGT->inkeyBuffer ); - - if( hb_set.HB_SET_TYPEAHEAD > HB_DEFAULT_INKEY_BUFSIZE ) - { - s_curGT->inkeyBufferSize = hb_set.HB_SET_TYPEAHEAD; - s_curGT->inkeyBuffer = ( int * ) hb_xgrab( s_curGT->inkeyBufferSize * sizeof( int ) ); - } - else - { - s_curGT->inkeyBufferSize = HB_DEFAULT_INKEY_BUFSIZE; - s_curGT->inkeyBuffer = s_curGT->defaultKeyBuffer; - } + pGT->inkeyBufferSize = HB_DEFAULT_INKEY_BUFSIZE; + pGT->inkeyBuffer = pGT->defaultKeyBuffer; } } } /* reset inkey pool to default state and free any allocated resources */ -static void hb_gt_def_InkeyExit( void ) +static void hb_gt_def_InkeyExit( PHB_GT pGT ) { - HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyExit()")); + HB_TRACE(HB_TR_DEBUG, ("hb_gt_def_InkeyExit(%p)", pGT)); - if( s_curGT ) + if( pGT->StrBuffer ) { - if( s_curGT->StrBuffer ) - { - hb_xfree( s_curGT->StrBuffer ); - s_curGT->StrBuffer = NULL; - } - if( s_curGT->inkeyBufferSize > HB_DEFAULT_INKEY_BUFSIZE ) - { - hb_xfree( s_curGT->inkeyBuffer ); - s_curGT->inkeyBufferSize = HB_DEFAULT_INKEY_BUFSIZE; - s_curGT->inkeyBuffer = s_curGT->defaultKeyBuffer; - } - + hb_xfree( pGT->StrBuffer ); + pGT->StrBuffer = NULL; + } + if( pGT->inkeyBufferSize > HB_DEFAULT_INKEY_BUFSIZE ) + { + hb_xfree( pGT->inkeyBuffer ); + pGT->inkeyBufferSize = HB_DEFAULT_INKEY_BUFSIZE; + pGT->inkeyBuffer = pGT->defaultKeyBuffer; } } -static void hb_gt_def_MouseInit( void ) +static void hb_gt_def_MouseInit( PHB_GT pGT ) { - ; + HB_SYMBOL_UNUSED( pGT ); } -static void hb_gt_def_MouseExit( void ) +static void hb_gt_def_MouseExit( PHB_GT pGT ) { - ; + HB_SYMBOL_UNUSED( pGT ); } -static BOOL hb_gt_def_MouseIsPresent( void ) +static BOOL hb_gt_def_MouseIsPresent( PHB_GT pGT ) { + HB_SYMBOL_UNUSED( pGT ); return FALSE; } -static void hb_gt_def_MouseShow( void ) +static void hb_gt_def_MouseShow( PHB_GT pGT ) { - ; + HB_SYMBOL_UNUSED( pGT ); } -static void hb_gt_def_MouseHide( void ) +static void hb_gt_def_MouseHide( PHB_GT pGT ) { - ; + HB_SYMBOL_UNUSED( pGT ); } -static BOOL hb_gt_def_MouseGetCursor( void ) +static BOOL hb_gt_def_MouseGetCursor( PHB_GT pGT ) { - return s_curGT ? s_curGT->fMouseVisible : FALSE; + return pGT->fMouseVisible; } -static void hb_gt_def_MouseSetCursor( BOOL fVisible ) +static void hb_gt_def_MouseSetCursor( PHB_GT pGT, BOOL fVisible ) { - if( !s_curGT ) - return; - else if( fVisible ) + if( fVisible ) { - hb_mouse_Show(); - s_curGT->fMouseVisible = TRUE; + HB_GTSELF_MOUSESHOW( pGT ); + pGT->fMouseVisible = TRUE; } - else if( s_curGT->fMouseVisible ) + else if( pGT->fMouseVisible ) { /* * mouse drivers use hide counters, so repeated calls to - * hb_mouse_Hide() will need at least the same number of calls to - * hb_mouse_Show() to make mouse cursor visible. This behavior - * is not compatible with Clipper so call to hb_mouse_Hide() is - * guarded by s_curGT->fMouseVisible. The counter is not updated when - * mouse cursor is visible and hb_mouse_Show() is called so this - * behavior is enough. If some platform works in differ way then - * and this behavior will create problems GT driver should overload - * hb_mouse_SetCursor()/hb_mouse_GetCursor() methods. [druzus] + * HB_GTSELF_MOUSEHIDE( pGT ) will need at least the same number of + * calls to HB_GTSELF_MOUSESHOW() to make mouse cursor visible. This + * behavior is not compatible with Clipper so call to + * HB_GTSELF_MOUSEHIDE( pGT ) is guarded by pGT->fMouseVisible. + * The counter is not updated when mouse cursor is visible and + * HB_GTSELF_MOUSESHOW() is called so this behavior is enough. + * If some platform works in differ way then and this behavior + * will create problems GT driver should overload + * HB_GTSELF_MOUSESETCURSOR()/HB_GTSELF_MOUSEGETCURSOR() methods. + * [druzus] */ - hb_mouse_Hide(); - s_curGT->fMouseVisible = FALSE; + HB_GTSELF_MOUSEHIDE( pGT ); + pGT->fMouseVisible = FALSE; } } -static int hb_gt_def_MouseRow( void ) +static int hb_gt_def_MouseRow( PHB_GT pGT ) { int iRow, iCol; - hb_mouse_GetPos( &iRow, &iCol ); + HB_GTSELF_MOUSEGETPOS( pGT, &iRow, &iCol ); return iRow; } -static int hb_gt_def_MouseCol( void ) +static int hb_gt_def_MouseCol( PHB_GT pGT ) { int iRow, iCol; - hb_mouse_GetPos( &iRow, &iCol ); + HB_GTSELF_MOUSEGETPOS( pGT, &iRow, &iCol ); return iCol; } -static void hb_gt_def_MouseGetPos( int * piRow, int * piCol ) +static void hb_gt_def_MouseGetPos( PHB_GT pGT, int * piRow, int * piCol ) { + HB_SYMBOL_UNUSED( pGT ); + *piRow = *piCol = 0; } -static void hb_gt_def_MouseSetPos( int iRow, int iCol ) +static void hb_gt_def_MouseSetPos( PHB_GT pGT, int iRow, int iCol ) { + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( iRow ); HB_SYMBOL_UNUSED( iCol ); } -static void hb_gt_def_MouseSetBounds( int iTop, int iLeft, int iBottom, int iRight ) +static void hb_gt_def_MouseSetBounds( PHB_GT pGT, int iTop, int iLeft, int iBottom, int iRight ) { + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( iTop ); HB_SYMBOL_UNUSED( iLeft ); HB_SYMBOL_UNUSED( iBottom ); HB_SYMBOL_UNUSED( iRight ); } -static void hb_gt_def_MouseGetBounds( int * piTop, int * piLeft, int * piBottom, int * piRight ) +static void hb_gt_def_MouseGetBounds( PHB_GT pGT, int * piTop, int * piLeft, int * piBottom, int * piRight ) { + HB_SYMBOL_UNUSED( pGT ); + *piTop = *piLeft = 0; - hb_gt_GetSize( piBottom, piRight ); + HB_GTSELF_GETSIZE( pGT, piBottom, piRight ); --(*piBottom); --(*piRight); } @@ -2649,62 +2563,68 @@ typedef struct int iRight; } _HB_MOUSE_STORAGE; -static int hb_gt_def_mouseStorageSize( void ) +static int hb_gt_def_mouseStorageSize( PHB_GT pGT ) { + HB_SYMBOL_UNUSED( pGT ); + return sizeof( _HB_MOUSE_STORAGE ); } -static void hb_gt_def_mouseSaveState( BYTE * pBuffer ) +static void hb_gt_def_mouseSaveState( PHB_GT pGT, BYTE * pBuffer ) { _HB_MOUSE_STORAGE * pStore = ( _HB_MOUSE_STORAGE * ) pBuffer; int iRow, iCol, iTop, iLeft, iBottom, iRight; - hb_mouse_GetPos( &iRow, &iCol ); - hb_mouse_GetBounds( &iTop, &iLeft, &iBottom, &iRight ); + HB_GTSELF_MOUSEGETPOS( pGT, &iRow, &iCol ); + HB_GTSELF_MOUSEGETBOUNDS( pGT, &iTop, &iLeft, &iBottom, &iRight ); pStore->iRow = iRow; pStore->iCol = iCol; - pStore->fVisible = hb_mouse_GetCursor(); + pStore->fVisible = HB_GTSELF_MOUSEGETCURSOR( pGT ); pStore->iTop = iTop; pStore->iLeft = iLeft; pStore->iBottom = iBottom; pStore->iRight = iRight; } -static void hb_gt_def_mouseRestoreState( BYTE * pBuffer ) +static void hb_gt_def_mouseRestoreState( PHB_GT pGT, BYTE * pBuffer ) { _HB_MOUSE_STORAGE * pStore = ( _HB_MOUSE_STORAGE * ) pBuffer; - hb_mouse_SetBounds( pStore->iTop, pStore->iLeft, pStore->iBottom, pStore->iRight ); - hb_mouse_SetPos( pStore->iRow, pStore->iCol ); - hb_mouse_SetCursor( pStore->fVisible ); + HB_GTSELF_MOUSESETBOUNDS( pGT, pStore->iTop, pStore->iLeft, pStore->iBottom, pStore->iRight ); + HB_GTSELF_MOUSESETPOS( pGT, pStore->iRow, pStore->iCol ); + HB_GTSELF_MOUSESETCURSOR( pGT, pStore->fVisible ); } -static int hb_gt_def_mouseGetDoubleClickSpeed( void ) +static int hb_gt_def_mouseGetDoubleClickSpeed( PHB_GT pGT ) { - return s_curGT ? s_curGT->iDoubleClickSpeed : 0; + return pGT->iDoubleClickSpeed; } -static void hb_gt_def_mouseSetDoubleClickSpeed( int iSpeed ) +static void hb_gt_def_mouseSetDoubleClickSpeed( PHB_GT pGT, int iSpeed ) { - if( s_curGT && iSpeed > 0 ) - s_curGT->iDoubleClickSpeed = iSpeed; + if( iSpeed > 0 ) + pGT->iDoubleClickSpeed = iSpeed; } -static int hb_gt_def_MouseCountButton( void ) +static int hb_gt_def_MouseCountButton( PHB_GT pGT ) { + HB_SYMBOL_UNUSED( pGT ); + return 0; } -static BOOL hb_gt_def_MouseButtonState( int iButton ) +static BOOL hb_gt_def_MouseButtonState( PHB_GT pGT, int iButton ) { + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( iButton ); return FALSE; } -static BOOL hb_gt_def_MouseButtonPressed( int iButton, int * piRow, int * piCol ) +static BOOL hb_gt_def_MouseButtonPressed( PHB_GT pGT, int iButton, int * piRow, int * piCol ) { + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( iButton ); HB_SYMBOL_UNUSED( piRow ); HB_SYMBOL_UNUSED( piCol ); @@ -2712,8 +2632,9 @@ static BOOL hb_gt_def_MouseButtonPressed( int iButton, int * piRow, int * piCol return FALSE; } -static BOOL hb_gt_def_MouseButtonReleased( int iButton, int * piRow, int * piCol ) +static BOOL hb_gt_def_MouseButtonReleased( PHB_GT pGT, int iButton, int * piRow, int * piCol ) { + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( iButton ); HB_SYMBOL_UNUSED( piRow ); HB_SYMBOL_UNUSED( piCol ); @@ -2721,58 +2642,58 @@ static BOOL hb_gt_def_MouseButtonReleased( int iButton, int * piRow, int * piCol return FALSE; } -static int hb_gt_def_MouseReadKey( int iEventMask ) +static int hb_gt_def_MouseReadKey( PHB_GT pGT, int iEventMask ) { int iKey = 0, iRow, iCol; - if( s_curGT && hb_mouse_IsPresent() ) + if( HB_GTSELF_MOUSEISPRESENT( pGT ) ) { - if( iEventMask & INKEY_LDOWN && hb_mouse_ButtonPressed( 0, &iRow, &iCol ) ) + if( iEventMask & INKEY_LDOWN && HB_GTSELF_MOUSEBUTTONPRESSED( pGT, 0, &iRow, &iCol ) ) { HB_ULONG timer = hb_dateMilliSeconds(); - if( timer - s_curGT->iMouseLeftTimer <= ( HB_ULONG ) hb_mouse_GetDoubleClickSpeed() ) + if( timer - pGT->iMouseLeftTimer <= ( HB_ULONG ) HB_GTSELF_MOUSEGETDOUBLECLICKSPEED( pGT ) ) iKey = K_LDBLCLK; else iKey = K_LBUTTONDOWN; - s_curGT->iMouseLeftTimer = timer; + pGT->iMouseLeftTimer = timer; } - else if( iEventMask & INKEY_LUP && hb_mouse_ButtonReleased( 0, &iRow, &iCol ) ) + else if( iEventMask & INKEY_LUP && HB_GTSELF_MOUSEBUTTONRELEASED( pGT, 0, &iRow, &iCol ) ) { iKey = K_LBUTTONUP; } - else if( iEventMask & INKEY_RDOWN && hb_mouse_ButtonPressed( 1, &iRow, &iCol ) ) + else if( iEventMask & INKEY_RDOWN && HB_GTSELF_MOUSEBUTTONPRESSED( pGT, 1, &iRow, &iCol ) ) { HB_ULONG timer = hb_dateMilliSeconds(); - if( timer - s_curGT->iMouseRightTimer <= ( HB_ULONG ) hb_mouse_GetDoubleClickSpeed() ) + if( timer - pGT->iMouseRightTimer <= ( HB_ULONG ) HB_GTSELF_MOUSEGETDOUBLECLICKSPEED( pGT ) ) iKey = K_RDBLCLK; else iKey = K_RBUTTONDOWN; - s_curGT->iMouseRightTimer = timer; + pGT->iMouseRightTimer = timer; } - else if( iEventMask & INKEY_RUP && hb_mouse_ButtonReleased( 1, &iRow, &iCol ) ) + else if( iEventMask & INKEY_RUP && HB_GTSELF_MOUSEBUTTONRELEASED( pGT, 1, &iRow, &iCol ) ) { iKey = K_RBUTTONUP; } - else if( iEventMask & INKEY_MMIDDLE && hb_mouse_ButtonPressed( 2, &iRow, &iCol ) ) + else if( iEventMask & INKEY_MMIDDLE && HB_GTSELF_MOUSEBUTTONPRESSED( pGT, 2, &iRow, &iCol ) ) { HB_ULONG timer = hb_dateMilliSeconds(); - if( timer - s_curGT->iMouseMiddleTimer <= ( HB_ULONG ) hb_mouse_GetDoubleClickSpeed() ) + if( timer - pGT->iMouseMiddleTimer <= ( HB_ULONG ) HB_GTSELF_MOUSEGETDOUBLECLICKSPEED( pGT ) ) iKey = K_MDBLCLK; else iKey = K_MBUTTONDOWN; - s_curGT->iMouseMiddleTimer = timer; + pGT->iMouseMiddleTimer = timer; } - else if( iEventMask & INKEY_MMIDDLE && hb_mouse_ButtonReleased( 2, &iRow, &iCol ) ) + else if( iEventMask & INKEY_MMIDDLE && HB_GTSELF_MOUSEBUTTONRELEASED( pGT, 2, &iRow, &iCol ) ) { iKey = K_MBUTTONUP; } else if( iEventMask & INKEY_MOVE ) { - hb_mouse_GetPos( &iRow, &iCol ); - if( iRow != s_curGT->iMouseLastRow || iCol != s_curGT->iMouseLastCol ) + HB_GTSELF_MOUSEGETPOS( pGT, &iRow, &iCol ); + if( iRow != pGT->iMouseLastRow || iCol != pGT->iMouseLastCol ) { - s_curGT->iMouseLastRow = iRow; - s_curGT->iMouseLastCol = iCol; + pGT->iMouseLastRow = iRow; + pGT->iMouseLastCol = iCol; iKey = K_MOUSEMOVE; } } @@ -2780,8 +2701,9 @@ static int hb_gt_def_MouseReadKey( int iEventMask ) return iKey; } -static int hb_gt_def_GfxPrimitive( int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor ) +static int hb_gt_def_GfxPrimitive( PHB_GT pGT, int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor ) { + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( iType ); HB_SYMBOL_UNUSED( iTop ); HB_SYMBOL_UNUSED( iLeft ); @@ -2792,8 +2714,9 @@ static int hb_gt_def_GfxPrimitive( int iType, int iTop, int iLeft, int iBottom, return 0; } -static void hb_gt_def_GfxText( int iTop, int iLeft, char * szText, int iColor, int iSize, int iWidth ) +static void hb_gt_def_GfxText( PHB_GT pGT, int iTop, int iLeft, char * szText, int iColor, int iSize, int iWidth ) { + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( iTop ); HB_SYMBOL_UNUSED( iLeft ); HB_SYMBOL_UNUSED( szText ); @@ -2802,15 +2725,16 @@ static void hb_gt_def_GfxText( int iTop, int iLeft, char * szText, int iColor, i HB_SYMBOL_UNUSED( iWidth ); } -static void hb_gt_def_WhoCares( void * pCargo ) +static void hb_gt_def_WhoCares( PHB_GT pGT, void * pCargo ) { + HB_SYMBOL_UNUSED( pGT ); HB_SYMBOL_UNUSED( pCargo ); } /* ************************************************************************* */ #if defined( __GNUC__ ) && 0 -static HB_GT_FUNCS gtCoreFunc = +static HB_GT_FUNCS s_gtCoreFunc = { Init : hb_gt_def_Init , Exit : hb_gt_def_Exit , @@ -2927,7 +2851,7 @@ static HB_GT_FUNCS gtCoreFunc = WhoCares : hb_gt_def_WhoCares }; #else -static HB_GT_FUNCS gtCoreFunc = +static HB_GT_FUNCS s_gtCoreFunc = { hb_gt_def_Init , hb_gt_def_Exit , @@ -3044,573 +2968,6 @@ static HB_GT_FUNCS gtCoreFunc = hb_gt_def_WhoCares }; #endif -/* ************************************************************************* */ - -void * hb_gt_New( void ) -{ - return gtCoreFunc.New(); -} - -void hb_gt_Free( void * pGtPtr ) -{ - gtCoreFunc.Free( pGtPtr ); -} - -void hb_gt_Init( FHANDLE hStdIn, FHANDLE hStdOut, FHANDLE hStdErr ) -{ - gtCoreFunc.Init( hStdIn, hStdOut, hStdErr ); -} - -void hb_gt_Exit( void ) -{ - gtCoreFunc.Exit(); -} - -BOOL hb_gt_CheckPos( int iRow, int iCol, long *plIndex ) -{ - return gtCoreFunc.CheckPos( iRow, iCol, plIndex ); -} - -void hb_gt_GetPos( int * piRow, int * piCol ) -{ - gtCoreFunc.GetPos( piRow, piCol ); -} - -void hb_gt_SetPos( int iRow, int iCol ) -{ - gtCoreFunc.SetPos( iRow, iCol ); -} - -int hb_gt_MaxCol( void ) -{ - return gtCoreFunc.MaxCol(); -} - -int hb_gt_MaxRow( void ) -{ - return gtCoreFunc.MaxRow(); -} - -BOOL hb_gt_IsColor( void ) -{ - return gtCoreFunc.IsColor(); -} - -void hb_gt_GetColorStr( char * pszColorString ) -{ - gtCoreFunc.GetColorStr( pszColorString ); -} - -void hb_gt_SetColorStr( const char * pszColorString ) -{ - gtCoreFunc.SetColorStr( pszColorString ); -} - -void hb_gt_ColorSelect( int iColorInddex ) -{ - gtCoreFunc.ColorSelect( iColorInddex ); -} - -int hb_gt_GetColor( void ) -{ - return gtCoreFunc.GetColor(); -} - -int hb_gt_ColorNum( const char * pszColorString ) -{ - return gtCoreFunc.ColorNum( pszColorString ); -} - -void hb_gt_ColorsToString( int * pColors, int iColorCount, char * pszColorString, int iBufSize ) -{ - gtCoreFunc.ColorsToString( pColors, iColorCount, pszColorString, iBufSize ); -} - -void hb_gt_StringToColors( const char * pszColorString, int ** pColorsPtr, int * piColorCount ) -{ - gtCoreFunc.StringToColors( pszColorString, pColorsPtr, piColorCount ); -} - -void hb_gt_GetColorData( int ** pColorsPtr, int * piColorCount, int * piColorIndex ) -{ - gtCoreFunc.GetColorData( pColorsPtr, piColorCount, piColorIndex ); -} - -int hb_gt_GetClearColor( void ) -{ - return gtCoreFunc.GetClearColor(); -} - -void hb_gt_SetClearColor( int iColor ) -{ - gtCoreFunc.SetClearColor( iColor ); -} - -int hb_gt_GetClearChar( void ) -{ - return gtCoreFunc.GetClearChar(); -} - -void hb_gt_SetClearChar( int iChar ) -{ - gtCoreFunc.SetClearChar( iChar ); -} - -int hb_gt_GetCursorStyle( void ) -{ - return gtCoreFunc.GetCursorStyle(); -} - -void hb_gt_SetCursorStyle( int iStyle ) -{ - gtCoreFunc.SetCursorStyle( iStyle ); -} - -void hb_gt_GetScrCursor( int * piRow, int * piCol, int * piStyle ) -{ - gtCoreFunc.GetScrCursor( piRow, piCol, piStyle ); -} - -BOOL hb_gt_GetBlink( void ) -{ - return gtCoreFunc.GetBlink(); -} - -void hb_gt_SetBlink( BOOL fBlink ) -{ - gtCoreFunc.SetBlink( fBlink ); -} - -void hb_gt_SetSnowFlag( BOOL fNoSnow ) -{ - gtCoreFunc.SetSnowFlag( fNoSnow ); -} - -void hb_gt_DispBegin( void ) -{ - gtCoreFunc.DispBegin(); -} - -void hb_gt_DispEnd( void ) -{ - gtCoreFunc.DispEnd(); -} - -int hb_gt_DispCount( void ) -{ - return gtCoreFunc.DispCount(); -} - -BOOL hb_gt_PreExt() -{ - return gtCoreFunc.PreExt(); -} - -BOOL hb_gt_PostExt() -{ - return gtCoreFunc.PostExt(); -} - -BOOL hb_gt_Suspend() -{ - return gtCoreFunc.Suspend(); -} - -BOOL hb_gt_Resume() -{ - return gtCoreFunc.Resume(); -} - -char * hb_gt_Version( int iType ) -{ - return gtCoreFunc.Version( iType ); -} - -BOOL hb_gt_GetScrChar( int iRow, int iCol, BYTE * pbColor, BYTE * pbAttr, USHORT * pusChar ) -{ - return gtCoreFunc.GetScrChar( iRow, iCol, pbColor, pbAttr, pusChar ); -} - -BOOL hb_gt_GetChar( int iRow, int iCol, BYTE * pbColor, BYTE * pbAttr, USHORT * pusChar ) -{ - return gtCoreFunc.GetChar( iRow, iCol, pbColor, pbAttr, pusChar ); -} - -BOOL hb_gt_PutScrChar( int iRow, int iCol, BYTE bColor, BYTE bAttr, USHORT usChar ) -{ - return gtCoreFunc.PutScrChar( iRow, iCol, bColor, bAttr, usChar ); -} - -BOOL hb_gt_PutChar( int iRow, int iCol, BYTE bColor, BYTE bAttr, USHORT usChar ) -{ - return gtCoreFunc.PutChar( iRow, iCol, bColor, bAttr, usChar ); -} - -void hb_gt_PutText( int iRow, int iCol, BYTE bColor, BYTE * pText, ULONG ulLen ) -{ - gtCoreFunc.PutText( iRow, iCol, bColor, pText, ulLen ); -} - -void hb_gt_Replicate( int iRow, int iCol, BYTE bColor, BYTE bAttr, USHORT usChar, ULONG ulLen ) -{ - gtCoreFunc.Replicate( iRow, iCol, bColor, bAttr, usChar, ulLen ); -} - -void hb_gt_WriteAt( int iRow, int iCol, BYTE * pText, ULONG ulLength ) -{ - gtCoreFunc.WriteAt( iRow, iCol, pText, ulLength ); -} - -void hb_gt_Write( BYTE * pText, ULONG ulLength ) -{ - gtCoreFunc.Write( pText, ulLength ); -} - -void hb_gt_WriteCon( BYTE * pText, ULONG ulLength ) -{ - gtCoreFunc.WriteCon( pText, ulLength ); -} - -long hb_gt_RectSize( int iTop, int iLeft, int iBottom, int iRight ) -{ - return gtCoreFunc.RectSize( iTop, iLeft, iBottom, iRight ); -} - -void hb_gt_Save( int iTop, int iLeft, int iBottom, int iRight, BYTE * pBuffer ) -{ - gtCoreFunc.Save( iTop, iLeft, iBottom, iRight, pBuffer ); -} - -void hb_gt_Rest( int iTop, int iLeft, int iBottom, int iRight, BYTE * pBuffer ) -{ - gtCoreFunc.Rest( iTop, iLeft, iBottom, iRight, pBuffer ); -} - -void hb_gt_SetAttribute( int iTop, int iLeft, int iBottom, int iRight, BYTE bColor ) -{ - gtCoreFunc.SetAttribute( iTop, iLeft, iBottom, iRight, bColor ); -} - -void hb_gt_DrawShadow( int iTop, int iLeft, int iBottom, int iRight, BYTE bColor ) -{ - gtCoreFunc.DrawShadow( iTop, iLeft, iBottom, iRight, bColor ); -} - -void hb_gt_Scroll( int iTop, int iLeft, int iBottom, int iRight, BYTE bColor, BYTE bChar, int iRows, int iCols ) -{ - gtCoreFunc.Scroll( iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols ); -} - -void hb_gt_ScrollUp( int iRows, BYTE bColor, BYTE bChar ) -{ - gtCoreFunc.ScrollUp( iRows, bColor, bChar ); -} - -void hb_gt_Box( int iTop, int iLeft, int iBottom, int iRight, BYTE * pbyFrame, BYTE bColor ) -{ - gtCoreFunc.Box( iTop, iLeft, iBottom, iRight, pbyFrame, bColor ); -} - -void hb_gt_BoxS( int iTop, int iLeft, int iBottom, int iRight, BYTE * pbyFrame, BYTE bColor ) -{ - gtCoreFunc.BoxS( iTop, iLeft, iBottom, iRight, pbyFrame, bColor ); -} - -void hb_gt_BoxD( int iTop, int iLeft, int iBottom, int iRight, BYTE * pbyFrame, BYTE bColor ) -{ - gtCoreFunc.BoxD( iTop, iLeft, iBottom, iRight, pbyFrame, bColor ); -} - -void hb_gt_HorizLine( int iRow, int iLeft, int iRight, BYTE bChar, BYTE bColor ) -{ - gtCoreFunc.HorizLine( iRow, iLeft, iRight, bChar, bColor ); -} - -void hb_gt_VertLine( int iCol, int iTop, int iBottom, BYTE bChar, BYTE bColor ) -{ - gtCoreFunc.VertLine( iCol, iTop, iBottom, bChar, bColor ); -} - -BOOL hb_gt_SetMode( int iRows, int iCols ) -{ - return gtCoreFunc.SetMode( iRows, iCols ); -} - -BOOL hb_gt_Resize( int iRows, int iCols ) -{ - return gtCoreFunc.Resize( iRows, iCols ); -} - -void hb_gt_GetSize( int * piRows, int * piCols ) -{ - gtCoreFunc.GetSize( piRows, piCols ); -} - -void hb_gt_SemiCold( void ) -{ - gtCoreFunc.SemiCold(); -} - -void hb_gt_ColdArea( int iTop, int iLeft, int iBottom, int iRight ) -{ - gtCoreFunc.ColdArea( iTop, iLeft, iBottom, iRight ); -} - -void hb_gt_ExposeArea( int iTop, int iLeft, int iBottom, int iRight ) -{ - gtCoreFunc.ExposeArea( iTop, iLeft, iBottom, iRight ); -} - -void hb_gt_ScrollArea( int iTop, int iLeft, int iBottom, int iRight, BYTE bColor, BYTE bChar, int iRows, int iCols ) -{ - gtCoreFunc.ScrollArea( iTop, iLeft, iBottom, iRight, bColor, bChar, iRows, iCols ); -} - -void hb_gt_TouchCell( int iRow, int iCol ) -{ - gtCoreFunc.TouchCell( iRow, iCol ); -} - -void hb_gt_Redraw( int iRow, int iCol, int iSize ) -{ - gtCoreFunc.Redraw( iRow, iCol, iSize ); -} - -void hb_gt_Refresh( void ) -{ - gtCoreFunc.Refresh(); -} - -void hb_gt_Flush( void ) -{ - gtCoreFunc.Flush(); -} - -void hb_gt_Tone( double dFrequency, double dDuration ) -{ - gtCoreFunc.Tone( dFrequency, dDuration ); -} - -void hb_gt_Bell( void ) -{ - gtCoreFunc.Bell(); -} - -void hb_gt_OutStd( BYTE * pbyStr, ULONG ulLen ) -{ - gtCoreFunc.OutStd( pbyStr, ulLen ); -} - -void hb_gt_OutErr( BYTE * pbyStr, ULONG ulLen ) -{ - gtCoreFunc.OutErr( pbyStr, ulLen ); -} - -BOOL hb_gt_SetDispCP( char * pszTermCDP, char * pszHostCDP, BOOL fBox ) -{ - return gtCoreFunc.SetDispCP( pszTermCDP, pszHostCDP, fBox ); -} - -BOOL hb_gt_SetKeyCP( char * pszTermCDP, char * pszHostCDP ) -{ - return gtCoreFunc.SetKeyCP( pszTermCDP, pszHostCDP ); -} - -BOOL hb_gt_Info( int iType, PHB_GT_INFO pInfo ) -{ - return gtCoreFunc.Info( iType, pInfo ); -} - -int hb_gt_Alert( PHB_ITEM pMessage, PHB_ITEM pOptions, - int iClrNorm, int iClrHigh, double dDelay ) -{ - return gtCoreFunc.Alert( pMessage, pOptions, iClrNorm, iClrHigh, dDelay ); -} - -int hb_gt_SetFlag( int iType, int iNewValue ) -{ - return gtCoreFunc.SetFlag( iType, iNewValue ); -} - -int hb_gt_ReadKey( int iEventMask ) -{ - return gtCoreFunc.ReadKey( iEventMask ); -} - -int hb_inkey_Get( BOOL fWait, double dSeconds, int iEventMask ) -{ - return gtCoreFunc.InkeyGet( fWait, dSeconds, iEventMask ); -} - -void hb_inkey_Put( int iKey ) -{ - gtCoreFunc.InkeyPut( iKey ); -} - -int hb_inkey_Last( int iEventMask ) -{ - return gtCoreFunc.InkeyLast( iEventMask ); -} - -int hb_inkey_Next( int iEventMask ) -{ - return gtCoreFunc.InkeyNext( iEventMask ); -} - -void hb_inkey_Poll( void ) -{ - gtCoreFunc.InkeyPoll(); -} - -void hb_inkey_SetText( const char * szText, ULONG ulLen ) -{ - gtCoreFunc.InkeySetText( szText, ulLen ); -} - -int hb_inkey_SetLast( int iKey ) -{ - return gtCoreFunc.InkeySetLast( iKey ); -} - -void hb_inkey_Reset( void ) -{ - gtCoreFunc.InkeyReset(); -} - -void hb_inkey_Exit( void ) -{ - gtCoreFunc.InkeyExit(); -} - -void hb_mouse_Init( void ) -{ - gtCoreFunc.MouseInit(); -} - -void hb_mouse_Exit( void ) -{ - gtCoreFunc.MouseExit(); -} - -BOOL hb_mouse_IsPresent( void ) -{ - return gtCoreFunc.MouseIsPresent(); -} - -void hb_mouse_Show( void ) -{ - gtCoreFunc.MouseShow(); -} - -void hb_mouse_Hide( void ) -{ - gtCoreFunc.MouseHide(); -} - -BOOL hb_mouse_GetCursor( void ) -{ - return gtCoreFunc.MouseGetCursor(); -} - -void hb_mouse_SetCursor( BOOL fVisible ) -{ - gtCoreFunc.MouseSetCursor( fVisible ); -} - -int hb_mouse_Col( void ) -{ - return gtCoreFunc.MouseCol(); -} - -int hb_mouse_Row( void ) -{ - return gtCoreFunc.MouseRow(); -} - -void hb_mouse_GetPos( int * piRow, int * piCol ) -{ - gtCoreFunc.MouseGetPos( piRow, piCol ); -} - -void hb_mouse_SetPos( int iRow, int iCol ) -{ - gtCoreFunc.MouseSetPos( iRow, iCol ); -} - -void hb_mouse_SetBounds( int iTop, int iLeft, int iBottom, int iRight ) -{ - gtCoreFunc.MouseSetBounds( iTop, iLeft, iBottom, iRight ); -} - -void hb_mouse_GetBounds( int * piTop, int * piLeft, int * piBottom, int * piRight ) -{ - gtCoreFunc.MouseGetBounds( piTop, piLeft, piBottom, piRight ); -} - -int hb_mouse_StorageSize( void ) -{ - return gtCoreFunc.MouseStorageSize(); -} - -void hb_mouse_SaveState( BYTE * pBuffer ) -{ - gtCoreFunc.MouseSaveState( pBuffer ); -} - -void hb_mouse_RestoreState( BYTE * pBuffer ) -{ - gtCoreFunc.MouseRestoreState( pBuffer ); -} - -int hb_mouse_GetDoubleClickSpeed( void ) -{ - return gtCoreFunc.MouseGetDoubleClickSpeed(); -} - -void hb_mouse_SetDoubleClickSpeed( int iSpeed ) -{ - gtCoreFunc.MouseSetDoubleClickSpeed( iSpeed ); -} - -int hb_mouse_CountButton( void ) -{ - return gtCoreFunc.MouseCountButton(); -} - -BOOL hb_mouse_ButtonState( int iButton ) -{ - return gtCoreFunc.MouseButtonState( iButton ); -} - -BOOL hb_mouse_ButtonPressed( int iButton, int * piRow, int * piCol ) -{ - return gtCoreFunc.MouseButtonPressed( iButton, piRow, piCol ); -} - -BOOL hb_mouse_ButtonReleased( int iButton, int * piRow, int * piCol ) -{ - return gtCoreFunc.MouseButtonReleased( iButton, piRow, piCol ); -} - -int hb_mouse_ReadKey( int iEventMask ) -{ - return gtCoreFunc.MouseReadKey( iEventMask ); -} - -int hb_gt_GfxPrimitive( int iType, int iTop, int iLeft, int iBottom, int iRight, int iColor ) -{ - return gtCoreFunc.GfxPrimitive( iType, iTop, iLeft, iBottom, iRight, iColor ); -} - -void hb_gt_GfxText( int iTop, int iLeft, char * szText, int iColor, int iSize, int iWidth ) -{ - gtCoreFunc.GfxText( iTop, iLeft, szText, iColor, iSize, iWidth ); -} - -void hb_gt_WhoCares( void * pCargo ) -{ - gtCoreFunc.WhoCares( pCargo ); -} /* ************************************************************************* */ @@ -3639,7 +2996,7 @@ static int s_iGtCount = 0; HB_FUNC_EXTERN( HB_GTSYS ); -static char * hb_gtFindDefault( void ) +static char * hb_gt_FindDefault( void ) { char szFuncName[ 15 + HB_GT_NAME_MAX_ ]; int iPos; @@ -3658,7 +3015,7 @@ static char * hb_gtFindDefault( void ) return NULL; } -static int hb_gtFindEntry( const char * pszID ) +static int hb_gt_FindEntry( const char * pszID ) { int iPos; @@ -3681,7 +3038,7 @@ HB_EXPORT void hb_gtSetDefault( const char * szGtName ) HB_EXPORT BOOL hb_gtRegister( PHB_GT_INIT gtInit ) { - if( hb_gtFindEntry( gtInit->id ) == -1 ) + if( hb_gt_FindEntry( gtInit->id ) == -1 ) { s_gtInit[ s_iGtCount++ ] = gtInit; return TRUE; @@ -3698,12 +3055,12 @@ HB_EXPORT BOOL hb_gtLoad( const char * szGtName, PHB_GT_FUNCS pFuncTable ) if( hb_stricmp( szGtName, "nul" ) == 0 || hb_stricmp( szGtName, "null" ) == 0 ) return TRUE; - iPos = hb_gtFindEntry( szGtName ); + iPos = hb_gt_FindEntry( szGtName ); if( iPos != -1 ) { if( pFuncTable == NULL ) - pFuncTable = >CoreFunc; + pFuncTable = &s_gtCoreFunc; memcpy( s_gtInit[ iPos ]->pSuperTable, pFuncTable, sizeof( HB_GT_FUNCS ) ); if( !s_gtInit[ iPos ]->init( pFuncTable ) ) { @@ -3712,6 +3069,14 @@ HB_EXPORT BOOL hb_gtLoad( const char * szGtName, PHB_GT_FUNCS pFuncTable ) if( s_gtInit[ iPos ]->pGtId ) *s_gtInit[ iPos ]->pGtId = s_iGtLinkCount; s_gtLinkOrder[ s_iGtLinkCount++ ] = iPos; + + 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; } } @@ -3723,9 +3088,10 @@ HB_EXPORT BOOL hb_gtUnLoad( void ) while( s_iGtLinkCount > 0 ) { if( --s_iGtLinkCount == 0 ) - memcpy( >CoreFunc, + memcpy( &s_gtCoreFunc, s_gtInit[ s_gtLinkOrder[ s_iGtLinkCount ] ]->pSuperTable, sizeof( HB_GT_FUNCS ) ); + } return TRUE; @@ -3739,7 +3105,7 @@ HB_EXPORT void hb_gtStartupInit( void ) szGtName = hb_cmdargString( "GT" ); if( szGtName ) { - fInit = hb_gtLoad( szGtName, >CoreFunc ); + fInit = hb_gtLoad( szGtName, &s_gtCoreFunc ); hb_xfree( szGtName ); if( fInit ) return; @@ -3747,19 +3113,19 @@ HB_EXPORT void hb_gtStartupInit( void ) szGtName = hb_getenv( "HB_GT" ); if( szGtName ) { - fInit = hb_gtLoad( szGtName, >CoreFunc ); + fInit = hb_gtLoad( szGtName, &s_gtCoreFunc ); hb_xfree( szGtName ); if( fInit ) return; } - if( hb_gtLoad( hb_gtFindDefault(), >CoreFunc ) ) + if( hb_gtLoad( hb_gt_FindDefault(), &s_gtCoreFunc ) ) return; - if( hb_gtLoad( s_defaultGT, >CoreFunc ) ) + if( hb_gtLoad( s_defaultGT, &s_gtCoreFunc ) ) return; if( hb_dynsymFind( "HB_GT_NUL" ) ) /* GTNUL was explicitly requsted */ { - if( hb_gtLoad( "NUL", >CoreFunc ) ) + if( hb_gtLoad( "NUL", &s_gtCoreFunc ) ) return; } diff --git a/harbour/source/rtl/inkeyapi.c b/harbour/source/rtl/inkeyapi.c index 7813aa01db..aefc79c211 100644 --- a/harbour/source/rtl/inkeyapi.c +++ b/harbour/source/rtl/inkeyapi.c @@ -54,58 +54,86 @@ HB_EXPORT int hb_inkey( BOOL fWait, double dSeconds, int iEventMask ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_inkey(%d, %f, %d)", (int) fWait, dSeconds, iEventMask)); - return hb_inkey_Get( fWait, dSeconds, iEventMask ); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_INKEYGET( pGT, fWait, dSeconds, iEventMask ) : 0; } HB_EXPORT void hb_inkeyPut( int iKey ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_inkeyPut(%d)", iKey)); - hb_inkey_Put( iKey ); + pGT = hb_gt_Base(); + if( pGT ) + HB_GTSELF_INKEYPUT( pGT, iKey ); } HB_EXPORT int hb_inkeyLast( int iEventMask ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_inkeyLast(%d)", iEventMask)); - return hb_inkey_Last( iEventMask ); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_INKEYLAST( pGT, iEventMask ) : 0; } HB_EXPORT int hb_inkeyNext( int iEventMask ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_inkeyNext(%d)", iEventMask)); - return hb_inkey_Next( iEventMask ); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_INKEYNEXT( pGT, iEventMask ) : 0; } HB_EXPORT void hb_inkeyPoll( void ) { + PHB_GT pGT; + HB_TRACE( HB_TR_DEBUG, ("hb_inkeyPoll()") ); - hb_inkey_Poll(); + pGT = hb_gt_Base(); + if( pGT ) + HB_GTSELF_INKEYPOLL( pGT ); } HB_EXPORT int hb_inkeySetLast( int iKey ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_inkeySetLast(%d)", iKey)); - return hb_inkey_SetLast( iKey ); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_INKEYSETLAST( pGT, iKey ) : 0; } HB_EXPORT void hb_inkeySetText( const char * szText, ULONG ulLen ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_inkeySetText(%s,%lu)", szText, ulLen)); - hb_inkey_SetText( szText, ulLen ); + pGT = hb_gt_Base(); + if( pGT ) + HB_GTSELF_INKEYSETTEXT( pGT, szText, ulLen ); } HB_EXPORT void hb_inkeyReset( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_inkeyReset()")); - hb_inkey_Reset(); + pGT = hb_gt_Base(); + if( pGT ) + HB_GTSELF_INKEYRESET( pGT ); } HB_EXPORT void hb_inkeySetCancelKeys( int iCancelKey, int iCancelKeyEx ) diff --git a/harbour/source/rtl/mouseapi.c b/harbour/source/rtl/mouseapi.c index a264bdd3bb..7f82127641 100644 --- a/harbour/source/rtl/mouseapi.c +++ b/harbour/source/rtl/mouseapi.c @@ -72,133 +72,198 @@ HB_EXPORT BOOL hb_mouseIsPresent( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseIsPresent()")); - return hb_mouse_IsPresent(); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_MOUSEISPRESENT( pGT ) : FALSE; } HB_EXPORT BOOL hb_mouseGetCursor( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseGetCursor()")); - return hb_mouse_GetCursor(); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_MOUSEGETCURSOR( pGT ) : FALSE; } HB_EXPORT void hb_mouseSetCursor( BOOL fVisible ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseSetCursor(%d)", (int) fVisible)); - hb_mouse_SetCursor( fVisible ); + pGT = hb_gt_Base(); + if( pGT ) + HB_GTSELF_MOUSESETCURSOR( pGT, fVisible ); } HB_EXPORT int hb_mouseCol( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseCol()")); - return hb_mouse_Col(); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_MOUSECOL( pGT ) : 0; } HB_EXPORT int hb_mouseRow( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseRow()")); - return hb_mouse_Row(); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_MOUSEROW( pGT ) : 0; } HB_EXPORT void hb_mouseGetPos( int * piRow, int * piCol ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseSetPos(%p, %p)", piRow, piCol)); - hb_mouse_GetPos( piRow, piCol ); + pGT = hb_gt_Base(); + if( pGT ) + HB_GTSELF_MOUSEGETPOS( pGT, piRow, piCol ); } HB_EXPORT void hb_mouseSetPos( int iRow, int iCol ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseSetPos(%d, %d)", iRow, iCol)); - hb_mouse_SetPos( iRow, iCol ); + pGT = hb_gt_Base(); + if( pGT ) + HB_GTSELF_MOUSESETPOS( pGT, iRow, iCol ); } HB_EXPORT void hb_mouseSetBounds( int iTop, int iLeft, int iBottom, int iRight ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseSetBounds(%d, %d, %d, %d)", iTop, iLeft, iBottom, iRight)); - hb_mouse_SetBounds( iTop, iLeft, iBottom, iRight ); + pGT = hb_gt_Base(); + if( pGT ) + HB_GTSELF_MOUSESETBOUNDS( pGT, iTop, iLeft, iBottom, iRight ); } HB_EXPORT void hb_mouseGetBounds( int * piTop, int * piLeft, int * piBottom, int * piRight ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseSetBounds(%p, %p, %p, %p)", piTop, piLeft, piBottom, piRight)); - hb_mouse_GetBounds( piTop, piLeft, piBottom, piRight ); + pGT = hb_gt_Base(); + if( pGT ) + HB_GTSELF_MOUSEGETBOUNDS( pGT, piTop, piLeft, piBottom, piRight ); } HB_EXPORT int hb_mouseStorageSize( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseStorageSize()")); - return hb_mouse_StorageSize(); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_MOUSESTORAGESIZE( pGT ) : 0; } HB_EXPORT void hb_mouseSaveState( BYTE * pBuffer ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseSaveState(%p)", pBuffer)); - hb_mouse_SaveState( pBuffer ); + pGT = hb_gt_Base(); + if( pGT ) + HB_GTSELF_MOUSESAVESTATE( pGT, pBuffer ); } HB_EXPORT void hb_mouseRestoreState( BYTE * pBuffer ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseRestoreState(%p)", pBuffer)); - hb_mouse_RestoreState( pBuffer ); + pGT = hb_gt_Base(); + if( pGT ) + HB_GTSELF_MOUSERESTORESTATE( pGT, pBuffer ); } HB_EXPORT int hb_mouseGetDoubleClickSpeed( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseGetDoubleClickSpeed()")); - return hb_mouse_GetDoubleClickSpeed(); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_MOUSEGETDOUBLECLICKSPEED( pGT ) : 0; } HB_EXPORT void hb_mouseSetDoubleClickSpeed( int iSpeed ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseSetDoubleClickSpeed(%d)", iSpeed)); - hb_mouse_SetDoubleClickSpeed( iSpeed ); + pGT = hb_gt_Base(); + if( pGT ) + HB_GTSELF_MOUSESETDOUBLECLICKSPEED( pGT, iSpeed ); } HB_EXPORT int hb_mouseCountButton( void ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseCountButton()")); - return hb_mouse_CountButton(); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_MOUSECOUNTBUTTON( pGT ) : 0; } HB_EXPORT BOOL hb_mouseButtonState( int iButton ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseButtonState(%d)", iButton)); - return hb_mouse_ButtonState( iButton ); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_MOUSEBUTTONSTATE( pGT, iButton ) : FALSE; } HB_EXPORT BOOL hb_mouseButtonPressed( int iButton, int * piRow, int * piCol ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseButtonPressed(%d,%p,%p)", iButton, piRow, piCol)); - return hb_mouse_ButtonPressed( iButton, piRow, piCol ); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_MOUSEBUTTONPRESSED( pGT, iButton, piRow, piCol ) : FALSE; } HB_EXPORT BOOL hb_mouseButtonReleased( int iButton, int * piRow, int * piCol ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseButtonReleased(%d,%p,%p)", iButton, piRow, piCol)); - return hb_mouse_ButtonReleased( iButton, piRow, piCol ); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_MOUSEBUTTONRELEASED( pGT, iButton, piRow, piCol ) : FALSE; } HB_EXPORT int hb_mouseReadKey( int iEventMask ) { + PHB_GT pGT; + HB_TRACE(HB_TR_DEBUG, ("hb_mouseReadKey(%d)", iEventMask)); - return hb_mouse_ReadKey( iEventMask ); + pGT = hb_gt_Base(); + return pGT ? HB_GTSELF_MOUSEREADKEY( pGT, iEventMask ) : 0; }