void hb_memvarGetRefer( PHB_ITEM pItem, PHB_SYMB pMemvarSymb )
{
PHB_DYNS pDyn;
HB_TRACE( HB_TR_DEBUG, ( "hb_memvarGetRefer(%p, %p)", pItem, pMemvarSymb ) );
pDyn = ( PHB_DYNS ) pMemvarSymb->pDynSym;
if( pDyn )
{
PHB_ITEM pMemvar;
pMemvar = hb_dynsymGetMemvar( pDyn );
HB_TRACE( HB_TR_INFO, ( "Memvar item (%p)(%s) referenced", pMemvar, pMemvarSymb->szName ) );
if( pMemvar )
{
if( HB_IS_BYREF( pMemvar ) && ! HB_IS_ENUM( pMemvar ) )
hb_itemCopy( pItem, pMemvar );
else
{
/* value is already created */
pItem->type = HB_IT_BYREF | HB_IT_MEMVAR;
pItem->item.asMemvar.value = pMemvar;
hb_xRefInc( pMemvar );
}
}
else
{
/* Generate an error with retry possibility
* (user created error handler can make this variable accessible)
*/
PHB_ITEM pError;
pError = hb_errRT_New( ES_ERROR, NULL, EG_NOVAR, 1003,
NULL, pMemvarSymb->szName, 0, EF_CANRETRY );
while( hb_errLaunch( pError ) == E_RETRY )
{
pMemvar = hb_dynsymGetMemvar( pDyn );
if( pMemvar )
{
if( HB_IS_BYREF( pMemvar ) && ! HB_IS_ENUM( pMemvar ) )
hb_itemCopy( pItem, pMemvar );
else
{
/* value is already created */
pItem->type = HB_IT_BYREF | HB_IT_MEMVAR;
pItem->item.asMemvar.value = pMemvar;
hb_xRefInc( pMemvar );
}
break;
}
}
hb_errRelease( pError );
}
}
else
hb_errInternal( HB_EI_MVBADSYMBOL, NULL, pMemvarSymb->szName, NULL );
}
HB_ERRCODE hb_memvarGet( PHB_ITEM pItem, PHB_SYMB pMemvarSymb )
{
PHB_DYNS pDyn;
HB_ERRCODE bSuccess = HB_FAILURE;
HB_TRACE( HB_TR_DEBUG, ( "hb_memvarGet(%p, %p)", pItem, pMemvarSymb ) );
pDyn = pMemvarSymb->pDynSym;
if( pDyn )
{
PHB_ITEM pMemvar;
pMemvar = hb_dynsymGetMemvar( pDyn );
HB_TRACE( HB_TR_INFO, ( "Memvar item (%p)(%s) queried", pMemvar, pMemvarSymb->szName ) );
if( pMemvar )
{
/* value is already created
*/
if( HB_IS_BYREF( pMemvar ) )
hb_itemCopy( pItem, hb_itemUnRef( pMemvar ) );
else
hb_itemCopy( pItem, pMemvar );
bSuccess = HB_SUCCESS;
}
}
else
hb_errInternal( HB_EI_MVBADSYMBOL, NULL, pMemvarSymb->szName, NULL );
return bSuccess;
}
static HB_BOOL hb_i18n_setpluralform( PHB_I18N_TRANS pI18N, PHB_ITEM pForm,
HB_BOOL fBase )
{
HB_BOOL fResult = HB_FALSE;
if( pI18N && pForm )
{
if( HB_IS_EVALITEM( pForm ) )
{
if( fBase )
{
if( pI18N->base_plural_block )
hb_itemCopy( pI18N->base_plural_block, pForm );
else
pI18N->base_plural_block = hb_itemNew( pForm );
}
else
{
if( pI18N->plural_block )
hb_itemCopy( pI18N->plural_block, pForm );
else
pI18N->plural_block = hb_itemNew( pForm );
}
fResult = HB_TRUE;
}
else if( HB_IS_STRING( pForm ) )
{
int iForm = hb_i18n_pluralformfind( hb_itemGetCPtr( pForm ) );
if( iForm )
{
const char * szKey;
if( fBase )
{
if( pI18N->base_plural_block )
{
hb_itemRelease( pI18N->base_plural_block );
pI18N->base_plural_block = NULL;
}
pI18N->base_plural_form = iForm;
szKey = "BASE_LANG";
}
else
{
if( pI18N->plural_block )
{
hb_itemRelease( pI18N->plural_block );
pI18N->plural_block = NULL;
}
pI18N->plural_form = iForm;
szKey = "LANG";
}
hb_i18n_setitem( pI18N->table, szKey, hb_i18n_pluralformid( iForm ) );
fResult = HB_TRUE;
}
}
}
return fResult;
}
void hb_rddsqlSetError( HB_ERRCODE errCode, const char * szError, const char * szQuery, PHB_ITEM pItem, unsigned long ulAffectedRows )
{
s_errCode = errCode;
if( s_szError )
{
hb_xfree( s_szError );
s_szError = NULL;
}
if( szError )
s_szError = hb_strdup( szError );
if( s_szQuery )
{
hb_xfree( s_szQuery );
s_szQuery = NULL;
}
if( szQuery )
s_szQuery = hb_strdup( szQuery );
if( pItem )
hb_itemCopy( s_pItemNewID, pItem );
else
hb_itemClear( s_pItemNewID );
s_ulAffectedRows = ulAffectedRows;
}
static const char * hb_i18n_description( PHB_I18N_TRANS pI18N, PHB_ITEM pItem )
{
if( pI18N )
{
PHB_ITEM pKey = hb_itemPutCConst( NULL, "DESCRIPTION" ), pValue;
pValue = hb_hashGetItemPtr( pI18N->table, pKey, 0 );
if( pItem )
{
if( HB_IS_STRING( pItem ) )
{
if( pValue )
hb_itemCopy( pValue, pItem );
else
{
hb_hashAdd( pI18N->table, pKey, pItem );
pValue = hb_hashGetItemPtr( pI18N->table, pKey, 0 );
}
}
}
hb_itemRelease( pKey );
return hb_itemGetCPtr( pValue );
}
return NULL;
}
static HB_BOOL hb_i18n_getpluralform( PHB_I18N_TRANS pI18N, PHB_ITEM pOldForm,
HB_BOOL fBase )
{
HB_BOOL fResult = HB_FALSE;
if( pI18N )
{
if( pOldForm )
{
PHB_ITEM pBlock;
int iForm;
if( fBase )
{
pBlock = pI18N->base_plural_block;
iForm = pI18N->base_plural_form;
}
else
{
pBlock = pI18N->plural_block;
iForm = pI18N->plural_form;
}
if( pBlock )
hb_itemCopy( pOldForm, pBlock );
else if( iForm )
hb_itemPutC( pOldForm, hb_i18n_pluralformid( iForm ) );
else
hb_itemPutCConst( pOldForm, "EN" ); /* default is ENGLISH */
}
fResult = HB_TRUE;
}
return fResult;
}
/*
* Altera o valor de uma variavel de memoria em nivel xBase. Retorna 1 se for
* bem sucedido ou 0 em caso de erro.
* 01/07/2008 - 17:12:17
*/
int wxMemvarPut( char * szVarName, PHB_ITEM pValue )
{
HB_DYNS_PTR pDyn;
int result = 0;
#ifdef HB_THREAD_SUPPORT
HB_THREAD_STUB
pDyn = s_memvarThFindName( szVarName, (HB_STACK *) &HB_VM_STACK );
#else
pDyn = hb_dynsymFindName( szVarName );
#endif
/*
* Se a variavel não existir ... criamos ela aqui como pública!
*/
if( !pDyn )
{
PHB_ITEM pMemvar = hb_itemNew( NULL );
hb_itemPutC( pMemvar, szVarName );
hb_memvarCreateFromItem( pMemvar, VS_PUBLIC, NULL );
hb_itemRelease( pMemvar );
#ifdef HB_THREAD_SUPPORT
pDyn = s_memvarThFindName( szVarName, &HB_VM_STACK );
#else
pDyn = hb_dynsymFindName( szVarName );
#endif
}
if( pDyn )
{
/* there is dynamic symbol with the requested name - check if it is
* a memvar variable
*/
if( pDyn->hMemvar )
{
/* value is already created */
HB_ITEM_PTR pSetItem = hb_memvarGetValueByHandle( pDyn->hMemvar );
// JC1: the variable we have now can't be destroyed in the meanwhile.
// It could be changed, but this is a race condition that must be
// prevented at prg level.
if( HB_IS_BYREF( pSetItem ) )
{
pSetItem = hb_itemUnRef( pSetItem );
}
hb_itemCopy( pSetItem, pValue );
result = 1;
// Count this new value.
/* s_globalTable[ pDyn->hMemvar ].counter = 1; */
}
}
return result;
}
PHB_ITEM hb_i18n_gettext( PHB_ITEM pMsgID, PHB_ITEM pContext )
{
PHB_I18N_TRANS pI18N = hb_i18n_table();
PHB_CODEPAGE cdpage = NULL;
PHB_ITEM pMsgDst = pMsgID;
if( pI18N )
{
PHB_ITEM pTable = pContext && pI18N->context_table ?
hb_hashGetItemPtr( pI18N->context_table, pContext, 0 ) :
pI18N->default_context;
cdpage = pI18N->base_cdpage;
if( pTable )
{
pTable = hb_hashGetItemPtr( pTable, pMsgID, 0 );
if( pTable )
{
if( HB_IS_ARRAY( pTable ) )
pTable = hb_arrayGetItemPtr( pTable, 1 );
if( pTable && HB_IS_STRING( pTable ) )
{
pMsgID = pTable;
cdpage = pI18N->cdpage;
}
}
}
}
if( pMsgID )
{
if( HB_IS_STRING( pMsgID ) )
{
if( cdpage )
{
PHB_CODEPAGE cdp = hb_vmCDP();
if( cdp && cdp != cdpage )
{
if( pMsgDst != pMsgID )
{
hb_itemCopy( pMsgDst, pMsgID );
pMsgID = pMsgDst;
}
hb_i18n_transitm( pMsgID, cdpage, cdp );
}
}
}
else
pMsgID = NULL;
}
return pMsgID;
}
HB_ITEM_PTR hb_gcGripGet( HB_ITEM_PTR pOrigin )
{
HB_GARBAGE_PTR pAlloc;
#ifdef GC_RECYCLE
HB_CRITICAL_LOCK( hb_garbageAllocMutex );
if( s_pAvailableItems )
{
pAlloc = s_pAvailableItems;
hb_gcUnlink( &s_pAvailableItems, s_pAvailableItems );
HB_CRITICAL_UNLOCK( hb_garbageAllocMutex );
}
else
{
HB_CRITICAL_UNLOCK( hb_garbageAllocMutex );
pAlloc = ( HB_GARBAGE_PTR ) hb_xgrab( sizeof( HB_ITEM ) + sizeof( HB_GARBAGE ) );
}
#else
pAlloc = HB_GARBAGE_NEW( sizeof( HB_ITEM ) + sizeof( HB_GARBAGE ) );
#endif
if( pAlloc )
{
HB_ITEM_PTR pItem = ( HB_ITEM_PTR )( pAlloc + 1 );
pAlloc->pFunc = hb_gcGripRelease;
pAlloc->locked = 1;
pAlloc->used = s_uUsedFlag;
pItem->type = HB_IT_NIL;
if( pOrigin )
{
hb_itemCopy( pItem, pOrigin );
}
HB_THREAD_GUARD( hb_garbageAllocMutex, hb_gcLink( &s_pLockedBlock, pAlloc ) );
return pItem;
}
else
{
return NULL;
}
}
static void hb_memvarCreateFromDynSymbol( PHB_DYNS pDynVar, int iScope, PHB_ITEM pValue )
{
HB_TRACE( HB_TR_DEBUG, ( "hb_memvarCreateFromDynSymbol(%p, %d, %p)", pDynVar, iScope, pValue ) );
if( iScope & HB_VSCOMP_PUBLIC )
{
/* If the variable with the same name exists already
* then the current value have to be unchanged
*/
if( ! hb_dynsymGetMemvar( pDynVar ) )
{
PHB_ITEM pMemvar = hb_memvarValueNew();
hb_dynsymSetMemvar( pDynVar, pMemvar );
if( pValue )
{
hb_itemCopy( pMemvar, pValue );
/* Remove MEMOFLAG if exists (assignment from field). */
pMemvar->type &= ~HB_IT_MEMOFLAG;
}
else
{
/* new PUBLIC variable - initialize it to .F.
*/
pMemvar->type = HB_IT_LOGICAL;
/* NOTE: PUBLIC variables named CLIPPER and HARBOUR are initialized */
/* to .T., this is normal Clipper behaviour. [vszakats] */
pMemvar->item.asLogical.value =
( strcmp( pDynVar->pSymbol->szName, "HARBOUR" ) == 0 ||
strcmp( pDynVar->pSymbol->szName, "CLIPPER" ) == 0 );
}
}
}
else
{
/* Create new PRIVATE var and add it to the PRIVATE variables stack
*/
hb_memvarAddPrivate( pDynVar, pValue );
}
}
PHB_ITEM hb_gcGripGet( PHB_ITEM pOrigin )
{
PHB_GARBAGE pAlloc = HB_GARBAGE_NEW( sizeof( HB_ITEM ) );
PHB_ITEM pItem = ( PHB_ITEM ) HB_BLOCK_PTR( pAlloc );
pAlloc->pFuncs = &s_gcGripFuncs;
pAlloc->locked = 1;
pAlloc->used = s_uUsedFlag;
pItem->type = HB_IT_NIL;
HB_GC_LOCK();
hb_gcLink( &s_pLockedBlock, pAlloc );
HB_GC_UNLOCK();
if( pOrigin )
hb_itemCopy( pItem, pOrigin );
return pItem;
}
static HB_ERRCODE sqlbaseRddInfo( LPRDDNODE pRDD, HB_USHORT uiIndex, HB_ULONG ulConnect, PHB_ITEM pItem )
{
HB_ULONG ulConn;
SQLDDCONNECTION * pConn;
HB_SYMBOL_UNUSED( pRDD );
ulConn = ulConnect ? ulConnect : s_ulConnectionCurrent;
if( ulConn > 0 && ulConn <= s_ulConnectionCount )
pConn = s_pConnection[ ulConn - 1 ];
else
pConn = NULL;
switch( uiIndex )
{
case RDDI_REMOTE:
hb_itemPutL( pItem, HB_TRUE );
break;
case RDDI_CONNECTION:
{
HB_ULONG ulNewConnection = 0;
if( hb_itemType( pItem ) & HB_IT_NUMERIC )
ulNewConnection = hb_itemGetNL( pItem );
hb_itemPutNL( pItem, ulConnect ? ulConnect : s_ulConnectionCurrent );
if( ulNewConnection )
s_ulConnectionCurrent = ulNewConnection;
break;
}
case RDDI_ISDBF:
hb_itemPutL( pItem, HB_FALSE );
break;
case RDDI_CANPUTREC:
hb_itemPutL( pItem, HB_TRUE );
break;
case RDDI_CONNECT:
{
PSDDNODE pNode = NULL;
HB_ULONG ul;
const char * pStr;
pStr = hb_arrayGetCPtr( pItem, 1 );
if( pStr )
{
pNode = s_pSdd;
while( pNode )
{
if( ! hb_stricmp( pNode->Name, pStr ) )
break;
pNode = pNode->pNext;
}
}
hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 );
pConn = ( SQLDDCONNECTION * ) hb_xgrab( sizeof( SQLDDCONNECTION ) );
memset( pConn, 0, sizeof( SQLDDCONNECTION ) );
if( pNode && pNode->Connect( pConn, pItem ) == HB_SUCCESS )
{
pConn->pSDD = pNode;
/* Find free connection handle */
for( ul = 0; ul < s_ulConnectionCount; ul++ )
{
if( ! s_pConnection[ ul ] )
break;
}
if( ul >= s_ulConnectionCount )
{
/* Realloc connection table */
if( s_pConnection )
s_pConnection = ( SQLDDCONNECTION ** ) hb_xrealloc( s_pConnection, sizeof( SQLDDCONNECTION * ) * ( s_ulConnectionCount + CONNECTION_LIST_EXPAND ) );
else
s_pConnection = ( SQLDDCONNECTION ** ) hb_xgrab( sizeof( SQLDDCONNECTION * ) * CONNECTION_LIST_EXPAND );
memset( s_pConnection + s_ulConnectionCount, 0, sizeof( SQLDDCONNECTION * ) * CONNECTION_LIST_EXPAND );
ul = s_ulConnectionCount;
s_ulConnectionCount += CONNECTION_LIST_EXPAND;
}
s_pConnection[ ul ] = pConn;
ul++;
s_ulConnectionCurrent = ul;
}
else
{
hb_xfree( pConn );
ul = 0;
}
hb_itemPutNI( pItem, ul );
break;
}
case RDDI_DISCONNECT:
hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 );
if( pConn && ! pConn->uiAreaCount && pConn->pSDD->Disconnect( pConn ) == HB_SUCCESS )
{
hb_xfree( pConn );
s_pConnection[ ulConn - 1 ] = NULL;
if( s_ulConnectionCurrent == ulConn )
s_ulConnectionCurrent = 0;
hb_itemPutL( pItem, HB_TRUE );
return HB_SUCCESS;
}
hb_itemPutL( pItem, HB_FALSE );
return HB_SUCCESS;
case RDDI_EXECUTE:
hb_rddsqlSetError( 0, NULL, NULL, NULL, 0 );
if( pConn )
hb_itemPutL( pItem, pConn->pSDD->Execute( pConn, pItem ) == HB_SUCCESS );
else
hb_itemPutL( pItem, HB_FALSE );
return HB_SUCCESS;
case RDDI_ERROR:
hb_itemPutC( pItem, s_szError );
return HB_SUCCESS;
case RDDI_ERRORNO:
hb_itemPutNI( pItem, s_errCode );
return HB_SUCCESS;
case RDDI_QUERY:
hb_itemPutC( pItem, s_szQuery );
return HB_SUCCESS;
case RDDI_NEWID:
hb_itemCopy( pItem, s_pItemNewID );
return HB_SUCCESS;
case RDDI_AFFECTEDROWS:
hb_itemPutNInt( pItem, s_ulAffectedRows );
return HB_SUCCESS;
#if 0
default:
return SUPER_RDDINFO( pRDD, uiIndex, ulConnect, pItem );
#endif
}
return HB_SUCCESS;
}
/*
* This function pushes passed dynamic symbol that belongs to PRIVATE variable
* into the stack. The value will be popped from it if the variable falls
* outside the scope (either by using RELEASE, CLEAR ALL, CLEAR MEMORY or by
* an exit from the function/procedure)
*
*/
static void hb_memvarAddPrivate( PHB_DYNS pDynSym, PHB_ITEM pValue )
{
HB_STACK_TLS_PRELOAD
PHB_PRIVATE_STACK pPrivateStack;
PHB_ITEM pMemvar;
HB_TRACE( HB_TR_DEBUG, ( "hb_memvarAddPrivate(%p,%p)", pDynSym, pValue ) );
pPrivateStack = hb_stackGetPrivateStack();
pMemvar = hb_dynsymGetMemvar( pDynSym );
/* If the variable with the same name exists already
* and it's PRIVATE variable declared in this function then
* do not push new memvar on PRIVATEs stack
*/
if( pMemvar )
{
HB_SIZE nCount = pPrivateStack->count;
while( nCount > pPrivateStack->base )
{
if( pDynSym == pPrivateStack->stack[ nCount - 1 ].pDynSym )
break;
--nCount;
}
if( nCount <= pPrivateStack->base )
pMemvar = NULL;
}
if( ! pMemvar )
{
/* Allocate the value from the end of table
*/
if( pPrivateStack->count == pPrivateStack->size )
{
/* No more free values in the table - expand the table
*/
if( pPrivateStack->size == 0 )
{
pPrivateStack->stack = ( PHB_PRIVATE_ITEM )
hb_xgrab( sizeof( HB_PRIVATE_ITEM ) * TABLE_INITHB_VALUE );
pPrivateStack->size = TABLE_INITHB_VALUE;
pPrivateStack->count = pPrivateStack->base = 0;
}
else
{
pPrivateStack->size += TABLE_EXPANDHB_VALUE;
pPrivateStack->stack = ( PHB_PRIVATE_ITEM )
hb_xrealloc( pPrivateStack->stack,
sizeof( HB_PRIVATE_ITEM ) * pPrivateStack->size );
}
}
pPrivateStack->stack[ pPrivateStack->count ].pDynSym = pDynSym;
pPrivateStack->stack[ pPrivateStack->count++ ].pPrevMemvar = hb_dynsymGetMemvar( pDynSym );
if( pValue && HB_IS_MEMVAR( pValue ) )
{
pMemvar = pValue->item.asMemvar.value;
hb_xRefInc( pMemvar );
pValue = NULL;
}
else
pMemvar = hb_memvarValueNew();
hb_dynsymSetMemvar( pDynSym, pMemvar );
}
if( pValue )
{
hb_itemCopy( pMemvar, pValue );
/* Remove MEMOFLAG if exists (assignment from field). */
pMemvar->type &= ~HB_IT_MEMOFLAG;
}
}
CLIPPER WBRWPANE( PARAMS ) // ( hWnd, hDC, Self, bLine, aSizes, nFirstItem,
// nClrFore, nClrBack, hFont, aJustify, nStyle
// lCellStyle, lFocused ) -> nRowsSkipped
// bTextColor, bBkColor, nClrLine, nColorFondo, bFont ) // New's by CesoTech
#endif
{
HWND hWnd = ( HWND ) _parnl( 1 );
HDC hDC = ( HDC ) _parnl( 2 );
WORD wRows;
WORD wLastBottom = 0;
WORD wRow = 1;
WORD wSkipped = 1;
PCLIPVAR Self = _param( 3, -1 );
PCLIPVAR bLine = _param( 4, -1 );
PCLIPVAR pASizes = _param( 5, -1 );
HFONT hFont = ( HFONT ) _parnl( 9 );
HFONT hOldFont;
BOOL bDestroyDC = FALSE;
WORD wHeight ;
RECT rct, box, client;
WORD wIndex = _parni( 6 );
PCLIPVAR bClrFore = 0, bClrBack = 0;
COLORREF clrFore = 0;
COLORREF clrBack = 0;
HPEN hGrayPen = CreatePen( PS_SOLID, 1, GetSysColor( COLOR_BTNSHADOW ) ) ; // RGB( 128, 128, 128 ) );
HPEN hWhitePen = CreatePen( PS_SOLID, 1, GetSysColor( COLOR_BTNHIGHLIGHT ) ); // GetStockObject( WHITE_PEN );
#ifndef __HARBOUR__
BOOL bColBlock = pASizes->wType & BLOCK;
#else
BOOL bColBlock = hb_itemType( pASizes ) & BLOCK;
PHB_ITEM aLine = hb_itemNew( NULL );
#endif
PCLIPVAR pAJustify = ISARRAY( 10 ) ? _param( 10, -1 ): 0;
WORD nHeightCtrl ; // by CeSoTech
WORD nStyle = _parni( 11 );
if( PCOUNT() > 6 )
{
if( ISBLOCK( 7 ) )
bClrFore = _param( 7, -1 );
else
clrFore = _parnl( 7 );
}
if( PCOUNT() > 7 )
{
if( ISBLOCK( 8 ) )
{
bClrBack = _param( 8, -1 );
_cEval0( bClrBack );
clrBack = _parnl( -1 );
}
else
clrBack = _parnl( 8 );
}
if( ! hDC )
{
bDestroyDC = TRUE;
hDC = GetDC( hWnd );
}
if( ! pSkip )
pSkip = _Get_Sym( "SKIP" );
if( hFont )
hOldFont = SelectObject( hDC, hFont );
/////////////////////////
// Borremos el Area de la derecha no coubierta
if ( !bAdjBrowse && !bAdjLastCol )
{
GetClientRect( hWnd, &rct );
SetBkColor( hDC, _parnl( 17 ) ) ;
for( wIndex=wIndex ; wIndex <= (WORD) _parinfa( 5, NULL); wIndex++ )
{
rct.left += _parni( 5, wIndex ) ;
}
if ( !(nStyle == 0 || nStyle == 7 || nStyle == 8 || nStyle == 3) )
rct.left++;
ExtTextOut( hDC, rct.left, rct.top, ETO_OPAQUE | ETO_CLIPPED,
&rct, "", 0, 0 );
wIndex = _parni( 6 );
GetClientRect( hWnd, &rct );
}
/////////////////////////
GetClientRect( hWnd, &client );
nHeightCtrl = client.bottom-client.top ; // by CeSoTech
wHeight = wLineHeight + 1 ;
wRows = WBrwRowsC( hWnd, hDC, hFont );
if( ! bClrFore )
SetTextColor( hDC, clrFore );
SetBkColor( hDC, clrBack );
while( wRow <= wRows && wSkipped == 1 )
{
rct.top = client.top + ( bDrawHeaders ? wHeaderHeight+1 : 0 ) +
(wHeight * (wRow-1) ) ;
rct.bottom = rct.top + wHeight;
rct.left = 0;
rct.right = client.right;
#ifndef __HARBOUR__
_cEval0( bLine );
_xPushM( _eval );
if( bClrFore )
{
_cEval0( bClrFore );
SetTextColor( hDC, _parnl( -1 ) );
}
if( bClrBack )
{
_cEval0( bClrBack );
SetBkColor( hDC, _parnl( -1 ) );
}
if( bColBlock )
_cEval0( pASizes );
PaintTheLine( hDC, &rct, wIndex, _tos,
( bColBlock ? _eval : pASizes ),
hWhitePen, hGrayPen,
bColBlock, pAJustify, 0, FALSE, _parni( 11 ),
_parni ( 12 ), _parl( 13 ),
ISBLOCK( 14 ) ? _param( 14, -1 ) : 0, // CeSoTech
ISBLOCK( 15 ) ? _param( 15, -1 ) : 0, // CeSoTech
wRow, nHeightCtrl, // CeSoTech
ISNUM( 16 ) ? _parnl( 16 ) : -1, // CeSoTech
FALSE, FALSE, // CeSoTech
ISBLOCK( 18 ) ? _param( 18, -1 ) : 0, // CeSoTech
FALSE ) ;
_tos--;
_PutSym( pSkip );
_xPushM( Self );
_PutQ( 1 );
_xSend( 1 );
#else
{
// aLine.type = HB_IT_NIL;
// Esta extension de xHarbour no se puede aplicar en Harbour
// hb_itemForwardValue( aLine, hb_vmEvalBlock( bLine ) );
hb_itemCopy( aLine, hb_vmEvalBlock( bLine ) );
if( bClrFore )
{
_cEval0( bClrFore );
SetTextColor( hDC, _parnl( -1 ) );
}
if( bClrBack )
{
_cEval0( bClrBack );
SetBkColor( hDC, _parnl( -1 ) );
}
PaintTheLine( hDC, &rct, wIndex, aLine,
( bColBlock ? hb_vmEvalBlock( pASizes ) : pASizes ),
hWhitePen, hGrayPen,
bColBlock, pAJustify, 0, FALSE, _parnl( 11 ),
_parnl ( 12 ), _parl( 13 ),
ISBLOCK( 14 ) ? _param( 14, -1 ) : 0, // CeSoTech
ISBLOCK( 15 ) ? _param( 15, -1 ) : 0, // CeSoTech
wRow, nHeightCtrl, // CeSoTech
ISNUM( 16 ) ? _parnl( 16 ) : -1, // CeSoTech
FALSE, FALSE, // CeSoTech
ISBLOCK( 18 ) ? _param( 18, -1 ) : 0, // CeSoTech
FALSE ) ;
if ( pSkip )
{
hb_vmPushSymbol( hb_dynsymSymbol( pSkip ) );
hb_vmPush( Self );
hb_vmPushLong( 1 );
hb_vmDo( 1 );
}
}
#endif
wLastBottom = rct.bottom ;
wSkipped = _parni( -1 );
if( wSkipped == 1 )
wRow++;
}
////////////////////////
// Borremos el Area de Abajo no cubierta
GetClientRect( hWnd, &rct );
SetBkColor( hDC, _parnl( 17 ) ) ;
rct.top = wLastBottom + 1 ;
if ( wLastBottom == 0 ) // No Mostro Registros
rct.top = ( bDrawHeaders ? wHeaderHeight+1 : 0 ) ;
rct.bottom-= 1 + ( bDrawFooters ? wFooterHeight+1 : 0 ) ;
if (nStyle == 0 || nStyle == 5 || nStyle == 6 ||
nStyle == 9 || nStyle == 10 || nStyle == 3 )
rct.top--;
if ( !bDrawFooters )
rct.bottom++;
if ( rct.top < rct.bottom )
{
ExtTextOut( hDC, rct.left, rct.top, ETO_OPAQUE | ETO_CLIPPED,
&rct, "", 0, 0 );
}
////////////////////////
DeleteObject( hGrayPen );
DeleteObject( hWhitePen );
if( hFont )
SelectObject( hDC, hOldFont );
if( bDestroyDC )
ReleaseDC( hWnd, hDC );
_retni( wRow );
}
PHB_ITEM hb_i18n_ngettext( PHB_ITEM pNum, PHB_ITEM pMsgID, PHB_ITEM pContext )
{
PHB_I18N_TRANS pI18N = hb_i18n_table();
PHB_CODEPAGE cdpage = NULL;
PHB_ITEM pMsgDst = pMsgID;
PHB_ITEM pBlock = NULL;
int iPluralForm = 0;
if( pI18N )
{
PHB_ITEM pTable = pContext && pI18N->context_table ?
hb_hashGetItemPtr( pI18N->context_table, pContext, 0 ) :
pI18N->default_context;
cdpage = pI18N->base_cdpage;
pBlock = pI18N->base_plural_block;
iPluralForm = pI18N->base_plural_form;
if( pTable )
{
PHB_ITEM pMsg = HB_IS_ARRAY( pMsgID ) ?
hb_arrayGetItemPtr( pMsgID, 1 ) : pMsgID;
pTable = pMsg && HB_IS_STRING( pMsg ) ?
hb_hashGetItemPtr( pTable, pMsg, 0 ) : NULL;
if( pTable )
{
if( HB_IS_STRING( pTable ) ||
( HB_IS_ARRAY( pTable ) &&
( hb_arrayGetType( pTable, 1 ) & HB_IT_STRING ) != 0 ) )
{
pMsgID = pTable;
cdpage = pI18N->cdpage;
pBlock = pI18N->plural_block;
iPluralForm = pI18N->plural_form;
}
}
}
}
if( pMsgID && HB_IS_ARRAY( pMsgID ) )
{
long lIndex;
if( ! pNum )
lIndex = 1;
else if( pBlock )
{
hb_evalBlock1( pBlock, pNum );
lIndex = hb_parnl( -1 );
}
else
lIndex = hb_i18n_pluralindex( iPluralForm, pNum );
if( lIndex < 1 || ( lIndex != 1 &&
( hb_arrayGetType( pMsgID, lIndex ) & HB_IT_STRING ) == 0 ) )
lIndex = 1;
pMsgID = hb_arrayGetItemPtr( pMsgID, lIndex );
}
if( pMsgID )
{
if( HB_IS_STRING( pMsgID ) )
{
if( cdpage )
{
PHB_CODEPAGE cdp = hb_vmCDP();
if( cdp && cdp != cdpage )
{
if( pMsgDst != pMsgID )
{
hb_itemCopy( pMsgDst, pMsgID );
pMsgID = pMsgDst;
}
hb_i18n_transitm( pMsgID, cdpage, cdp );
}
}
}
else
pMsgID = NULL;
}
return pMsgID;
}