static PHB_SOCKEX s_sockexNew( HB_SOCKET sd, PHB_ITEM pParams )
{
PHB_SOCKEX pSock;
HB_BOOL fServer = HB_FALSE;
HB_MAXINT timeout = -1;
SSL * ssl = NULL;
if( pParams && HB_IS_HASH( pParams ) )
{
PHB_ITEM pItem;
if( ssl == NULL && ( pItem = hb_hashGetCItemPtr( pParams, "ssl" ) ) != NULL )
ssl = hb_SSL_itemGet( pItem );
if( ssl == NULL && ( pItem = hb_hashGetCItemPtr( pParams, "ctx" ) ) != NULL )
ssl = hb_SSL_itemGet( pItem );
if( ssl == NULL && ( pItem = hb_hashGetCItemPtr( pParams, "key" ) ) != NULL )
ssl = hb_SSL_itemGet( pItem );
if( ( pItem = hb_hashGetCItemPtr( pParams, "timeout" ) ) != NULL &&
HB_IS_NUMERIC( pItem ) )
timeout = hb_itemGetNInt( pItem );
if( ( pItem = hb_hashGetCItemPtr( pParams, "server" ) ) != NULL &&
HB_IS_LOGICAL( pItem ) )
fServer = hb_itemGetL( pItem );
else if( ( pItem = hb_hashGetCItemPtr( pParams, "client" ) ) != NULL &&
HB_IS_LOGICAL( pItem ) )
fServer = ! hb_itemGetL( pItem );
}
pSock = hb_sockexNewSSL( sd, ssl, fServer, timeout );
if( pSock )
hb_socekxParamsInit( pSock, pParams );
return pSock;
}
/*
* Copy one or more records from one WorkArea to another.
*/
static HB_ERRCODE hb_delimTrans( DELIMAREAP pArea, LPDBTRANSINFO pTransInfo )
{
HB_TRACE(HB_TR_DEBUG, ("hb_delimTrans(%p, %p)", pArea, pTransInfo));
if( pTransInfo->uiFlags & DBTF_MATCH )
{
if( !pArea->fTransRec || pArea->cdPage != pTransInfo->lpaDest->cdPage )
pTransInfo->uiFlags &= ~DBTF_PUTREC;
else if( pArea->rddID == pTransInfo->lpaDest->rddID )
pTransInfo->uiFlags |= DBTF_PUTREC;
else
{
PHB_ITEM pPutRec = hb_itemPutL( NULL, FALSE );
if( SELF_INFO( ( AREAP ) pTransInfo->lpaDest, DBI_CANPUTREC, pPutRec ) != HB_SUCCESS )
{
hb_itemRelease( pPutRec );
return HB_FAILURE;
}
if( hb_itemGetL( pPutRec ) )
pTransInfo->uiFlags |= DBTF_PUTREC;
else
pTransInfo->uiFlags &= ~DBTF_PUTREC;
hb_itemRelease( pPutRec );
}
}
return SUPER_TRANS( ( AREAP ) pArea, pTransInfo );
}
static char * hb_itemStringCon( PHB_ITEM pItem, HB_SIZE * pnLen, HB_BOOL * pfFreeReq )
{
/* logical values in device output (not console, stdout or stderr) are
shown as single letter */
if( HB_IS_LOGICAL( pItem ) )
{
*pnLen = 1;
*pfFreeReq = HB_FALSE;
return ( char * ) ( hb_itemGetL( pItem ) ? "T" : "F" );
}
return hb_itemString( pItem, pnLen, pfFreeReq );
}
static HB_ERRCODE hb_rddEvalWABlock( AREAP pArea, void * pBlock )
{
PHB_ITEM pItem;
hb_rddSelectWorkAreaNumber( pArea->uiArea );
pItem = hb_vmEvalBlockOrMacro( ( PHB_ITEM ) pBlock );
if( hb_vmRequestQuery() != 0 ||
( HB_IS_LOGICAL( pItem ) && ! hb_itemGetL( pItem ) ) )
return HB_FAILURE;
else
return HB_SUCCESS;
}
static PMIXKEY mixKeyNew( PHB_ITEM pItem, HB_ULONG ulRecNo, HB_BYTE bType, HB_USHORT uiLen )
{
PMIXKEY pKey;
double dbl;
HB_BYTE buf[ 8 ];
pKey = ( PMIXKEY ) hb_xgrab( sizeof( HB_ULONG ) + uiLen );
pKey->rec = ulRecNo;
switch( bType )
{
case 'C':
{
HB_SIZE ul = hb_itemGetCLen( pItem );
if( ul > ( HB_SIZE ) uiLen )
ul = uiLen;
memcpy( pKey->val, hb_itemGetCPtr( pItem ), ul );
if( ul < ( HB_SIZE ) uiLen )
memset( pKey->val + ul, ' ', ( HB_SIZE ) uiLen - ul );
break;
}
case 'N':
dbl = hb_itemGetND( pItem );
HB_DBL2ORD( &dbl, buf );
memcpy( pKey->val, buf, 8 );
break;
case 'D':
dbl = ( double ) hb_itemGetDL( pItem );
HB_DBL2ORD( &dbl, buf );
memcpy( pKey->val, buf, 8 );
break;
case 'L':
pKey->val[ 0 ] = ( HB_BYTE ) ( hb_itemGetL( pItem ) ? 'T' : 'F' );
break;
default:
memset( pKey->val, ' ', uiLen );
}
return pKey;
}
void hb_socekxParamsInit( PHB_SOCKEX pSock, PHB_ITEM pParams )
{
if( pParams && HB_IS_HASH( pParams ) )
{
PHB_ITEM pItem;
if( ( pItem = hb_hashGetCItemPtr( pParams, "readahead" ) ) != NULL &&
HB_IS_NUMERIC( pItem ) )
{
if( pSock->buffer == NULL )
pSock->readahead = hb_itemGetNL( pItem );
}
if( ( pItem = hb_hashGetCItemPtr( pParams, "flush" ) ) != NULL &&
HB_IS_NUMERIC( pItem ) )
pSock->iAutoFlush = hb_itemGetNI( pItem );
if( ( pItem = hb_hashGetCItemPtr( pParams, "redir" ) ) != NULL &&
HB_IS_LOGICAL( pItem ) )
pSock->fRedirAll = hb_itemGetL( pItem );
}
}
static HB_BOOL mixEvalCond( PHB_ITEM pCondItem, ADSXAREAP pArea )
{
int iCurrArea = 0;
HB_BOOL fRet;
if( pArea )
{
iCurrArea = hb_rddGetCurrentWorkAreaNumber();
if( iCurrArea != pArea->adsarea.area.uiArea )
hb_rddSelectWorkAreaNumber( pArea->adsarea.area.uiArea );
else
iCurrArea = 0;
}
fRet = hb_itemGetL( hb_vmEvalBlockOrMacro( pCondItem ) );
if( iCurrArea )
hb_rddSelectWorkAreaNumber( iCurrArea );
return fRet;
}
HB_USHORT hb_errLaunch( PHB_ITEM pError )
{
HB_USHORT uiAction = E_DEFAULT; /* Needed to avoid GCC -O2 warning */
HB_TRACE( HB_TR_DEBUG, ( "hb_errLaunch(%p)", pError ) );
if( pError )
{
PHB_ERRDATA pErrData = ( PHB_ERRDATA ) hb_stackGetTSD( &s_errData );
HB_USHORT uiFlags = hb_errGetFlags( pError );
PHB_ITEM pResult;
/* Check if we have a valid error handler */
if( ! pErrData->errorBlock || ! HB_IS_EVALITEM( pErrData->errorBlock ) )
hb_errInternal( HB_EI_ERRNOBLOCK, NULL, NULL, NULL );
/* Check if the error launcher was called too many times recursively */
if( pErrData->iLaunchCount == HB_ERROR_LAUNCH_MAX )
hb_errInternal( HB_EI_ERRTOOMANY, NULL, NULL, NULL );
/* Launch the error handler: "lResult := Eval( ErrorBlock(), oError )" */
pErrData->iLaunchCount++;
/* set DosError() to last OS error code */
pErrData->uiErrorDOS = ( int ) hb_errGetOsCode( pError );
/* Add one try to the counter. */
if( uiFlags & EF_CANRETRY )
hb_errPutTries( pError, ( HB_USHORT ) ( hb_errGetTries( pError ) + 1 ) );
if( pErrData->errorHandler )
{
/* there is a low-level error handler defined - use it instead
* of normal Harbour level one
*/
pErrData->errorHandler->Error = pError;
pErrData->errorHandler->ErrorBlock = pErrData->errorBlock;
pResult = ( pErrData->errorHandler->Func )( pErrData->errorHandler );
pErrData->errorHandler->Error = NULL;
}
else
pResult = hb_itemDo( pErrData->errorBlock, 1, pError );
pErrData->iLaunchCount--;
/* Check results */
if( hb_vmRequestQuery() != 0 )
{
if( pResult )
hb_itemRelease( pResult );
uiAction = E_BREAK;
}
else if( pResult )
{
HB_BOOL bFailure = HB_FALSE;
/* If the error block didn't return a logical value, */
/* or the canSubstitute flag has been set, consider it as a failure */
if( ! HB_IS_LOGICAL( pResult ) || ( uiFlags & EF_CANSUBSTITUTE ) )
bFailure = HB_TRUE;
else
{
uiAction = hb_itemGetL( pResult ) ? E_RETRY : E_DEFAULT;
if( ( uiAction == E_DEFAULT && !( uiFlags & EF_CANDEFAULT ) ) ||
( uiAction == E_RETRY && !( uiFlags & EF_CANRETRY ) ) )
bFailure = HB_TRUE;
}
hb_itemRelease( pResult );
if( bFailure )
hb_errInternal( HB_EI_ERRRECFAILURE, NULL, NULL, NULL );
}
else
hb_errInternal( HB_EI_ERRRECFAILURE, NULL, NULL, NULL );
}
else
uiAction = E_RETRY; /* Clipper does this, undocumented */
return uiAction;
}
static void _hb_jsonEncode( PHB_ITEM pValue, PHB_JSON_ENCODE_CTX pCtx,
HB_SIZE nLevel, HB_BOOL fEOL, PHB_CODEPAGE cdp )
{
/* Protection against recursive structures */
if( ( HB_IS_ARRAY( pValue ) || HB_IS_HASH( pValue ) ) && hb_itemSize( pValue ) > 0 )
{
void * id = HB_IS_HASH( pValue ) ? hb_hashId( pValue ) : hb_arrayId( pValue );
HB_SIZE nIndex;
for( nIndex = 0; nIndex < nLevel; nIndex++ )
{
if( pCtx->pId[ nIndex ] == id )
{
if( ! fEOL && pCtx->fHuman )
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
_hb_jsonCtxAdd( pCtx, "null", 4 );
return;
}
}
if( nLevel >= pCtx->nAllocId )
{
pCtx->nAllocId += 8;
pCtx->pId = ( void ** ) hb_xrealloc( pCtx->pId, sizeof( void * ) * pCtx->nAllocId );
}
pCtx->pId[ nLevel ] = id;
}
if( fEOL )
{
--pCtx->pHead;
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
}
if( HB_IS_STRING( pValue ) )
{
HB_SIZE nPos, nLen = hb_itemGetCLen( pValue );
const char * szString = hb_itemGetCPtr( pValue );
char buf[ 8 ];
_hb_jsonCtxAdd( pCtx, "\"", 1 );
if( cdp )
{
HB_WCHAR wc;
nPos = 0;
while( HB_CDPCHAR_GET( cdp, szString, nLen, &nPos, &wc ) )
{
if( wc >= ' ' && wc < 0x7F && wc != '\\' && wc != '\"' )
{
buf[ 0 ] = ( char ) wc;
_hb_jsonCtxAdd( pCtx, buf, 1 );
continue;
}
switch( wc )
{
case '\\':
_hb_jsonCtxAdd( pCtx, "\\\\", 2 );
break;
case '\"':
_hb_jsonCtxAdd( pCtx, "\\\"", 2 );
break;
case '\b':
_hb_jsonCtxAdd( pCtx, "\\b", 2 );
break;
case '\f':
_hb_jsonCtxAdd( pCtx, "\\f", 2 );
break;
case '\n':
_hb_jsonCtxAdd( pCtx, "\\n", 2 );
break;
case '\r':
_hb_jsonCtxAdd( pCtx, "\\r", 2 );
break;
case '\t':
_hb_jsonCtxAdd( pCtx, "\\t", 2 );
break;
default:
hb_snprintf( buf, sizeof( buf ), "\\u%04X", wc );
_hb_jsonCtxAdd( pCtx, buf, 6 );
break;
}
}
}
else
{
nPos = 0;
while( nPos < nLen )
{
unsigned char uch = szString[ nPos ];
HB_SIZE nPos2 = nPos;
while( uch >= ' ' && uch != '\\' && uch != '\"' )
uch = szString[ ++nPos2 ];
if( nPos2 > nPos )
{
_hb_jsonCtxAdd( pCtx, szString + nPos, nPos2 - nPos );
if( nPos2 >= nLen )
break;
nPos = nPos2;
}
switch( uch )
{
case '\\':
_hb_jsonCtxAdd( pCtx, "\\\\", 2 );
break;
case '\"':
_hb_jsonCtxAdd( pCtx, "\\\"", 2 );
break;
case '\b':
_hb_jsonCtxAdd( pCtx, "\\b", 2 );
break;
case '\f':
_hb_jsonCtxAdd( pCtx, "\\f", 2 );
break;
case '\n':
_hb_jsonCtxAdd( pCtx, "\\n", 2 );
break;
case '\r':
_hb_jsonCtxAdd( pCtx, "\\r", 2 );
break;
case '\t':
_hb_jsonCtxAdd( pCtx, "\\t", 2 );
break;
default:
hb_snprintf( buf, sizeof( buf ), "\\u00%02X", uch );
_hb_jsonCtxAdd( pCtx, buf, 6 );
break;
}
nPos++;
}
}
_hb_jsonCtxAdd( pCtx, "\"", 1 );
}
else if( HB_IS_NUMINT( pValue ) )
{
char buf[ 24 ];
HB_MAXINT nVal = hb_itemGetNInt( pValue );
HB_BOOL fNeg = nVal < 0;
int i = 0;
if( fNeg )
nVal = -nVal;
do
buf[ sizeof( buf ) - ++i ] = ( nVal % 10 ) + '0';
while( ( nVal /= 10 ) != 0 );
if( fNeg )
buf[ sizeof( buf ) - ++i ] = '-';
_hb_jsonCtxAdd( pCtx, &buf[ sizeof( buf ) - i ], i );
}
else if( HB_IS_NUMERIC( pValue ) )
{
char buf[ 64 ];
int iDec;
double dblValue = hb_itemGetNDDec( pValue, &iDec );
hb_snprintf( buf, sizeof( buf ), "%.*f", iDec, dblValue );
_hb_jsonCtxAdd( pCtx, buf, strlen( buf ) );
}
else if( HB_IS_NIL( pValue ) )
{
_hb_jsonCtxAdd( pCtx, "null", 4 );
}
else if( HB_IS_LOGICAL( pValue ) )
{
if( hb_itemGetL( pValue ) )
_hb_jsonCtxAdd( pCtx, "true", 4 );
else
_hb_jsonCtxAdd( pCtx, "false", 5 );
}
else if( HB_IS_DATE( pValue ) )
{
char szBuffer[ 10 ];
hb_itemGetDS( pValue, szBuffer + 1 );
szBuffer[ 0 ] = '\"';
szBuffer[ 9 ] = '\"';
_hb_jsonCtxAdd( pCtx, szBuffer, 10 );
}
else if( HB_IS_TIMESTAMP( pValue ) )
{
char szBuffer[ 19 ];
hb_itemGetTS( pValue, szBuffer + 1 );
szBuffer[ 0 ] = '\"';
szBuffer[ 18 ] = '\"';
_hb_jsonCtxAdd( pCtx, szBuffer, 19 );
}
else if( HB_IS_ARRAY( pValue ) )
{
HB_SIZE nLen = hb_itemSize( pValue );
if( nLen )
{
HB_SIZE nIndex;
if( pCtx->fHuman )
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
_hb_jsonCtxAdd( pCtx, "[", 1 );
for( nIndex = 1; nIndex <= nLen; nIndex++ )
{
PHB_ITEM pItem = hb_arrayGetItemPtr( pValue, nIndex );
if( nIndex > 1 )
_hb_jsonCtxAdd( pCtx, ",", 1 );
if( pCtx->fHuman )
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
if( pCtx->fHuman &&
! ( ( HB_IS_ARRAY( pItem ) || HB_IS_HASH( pItem ) ) &&
hb_itemSize( pItem ) > 0 ) )
_hb_jsonCtxAddIndent( pCtx, ( nLevel + 1 ) * INDENT_SIZE );
_hb_jsonEncode( pItem, pCtx, nLevel + 1, HB_FALSE, cdp );
}
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
}
_hb_jsonCtxAdd( pCtx, "]", 1 );
}
else
_hb_jsonCtxAdd( pCtx, "[]", 2 );
}
else if( HB_IS_HASH( pValue ) )
{
HB_SIZE nLen = hb_hashLen( pValue );
if( nLen )
{
HB_SIZE nIndex;
if( pCtx->fHuman )
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
_hb_jsonCtxAdd( pCtx, "{", 1 );
for( nIndex = 1; nIndex <= nLen; nIndex++ )
{
PHB_ITEM pKey = hb_hashGetKeyAt( pValue, nIndex );
if( HB_IS_STRING( pKey ) )
{
PHB_ITEM pItem = hb_hashGetValueAt( pValue, nIndex );
if( nIndex > 1 )
_hb_jsonCtxAdd( pCtx, ",", 1 );
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
_hb_jsonCtxAddIndent( pCtx, ( nLevel + 1 ) * INDENT_SIZE );
}
_hb_jsonEncode( pKey, pCtx, nLevel + 1, HB_FALSE, cdp );
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, ": ", 2 );
fEOL = ( HB_IS_ARRAY( pItem ) || HB_IS_HASH( pItem ) ) && hb_itemSize( pItem ) > 0;
}
else
{
_hb_jsonCtxAdd( pCtx, ":", 1 );
fEOL = HB_FALSE;
}
_hb_jsonEncode( pItem, pCtx, nLevel + 1, fEOL, cdp );
}
}
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
}
_hb_jsonCtxAdd( pCtx, "}", 1 );
}
else
_hb_jsonCtxAdd( pCtx, "{}", 2 );
}
else
{
/* All unsupported types are replacd by null */
_hb_jsonCtxAdd( pCtx, "null", 4 );
}
}
/*
* Assign a value to a field.
*/
static HB_ERRCODE hb_delimPutValue( DELIMAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
{
char szBuffer[ 256 ];
HB_ERRCODE uiError;
LPFIELD pField;
USHORT uiSize;
HB_TRACE(HB_TR_DEBUG, ("hb_delimPutValue(%p,%hu,%p)", pArea, uiIndex, pItem));
if( !pArea->fPositioned )
return HB_SUCCESS;
if( !pArea->fRecordChanged )
return HB_FAILURE;
uiError = HB_SUCCESS;
--uiIndex;
pField = pArea->lpFields + uiIndex;
if( pField->uiType != HB_FT_MEMO && pField->uiType != HB_FT_NONE )
{
if( HB_IS_MEMO( pItem ) || HB_IS_STRING( pItem ) )
{
if( pField->uiType == HB_FT_STRING )
{
uiSize = ( USHORT ) hb_itemGetCLen( pItem );
if( uiSize > pField->uiLen )
uiSize = pField->uiLen;
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
hb_itemGetCPtr( pItem ), uiSize );
#ifndef HB_CDP_SUPPORT_OFF
hb_cdpnTranslate( (char *) pArea->pRecord + pArea->pFieldOffset[ uiIndex ], hb_cdppage(), pArea->cdPage, uiSize );
#endif
memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] + uiSize,
' ', pField->uiLen - uiSize );
}
else
uiError = EDBF_DATATYPE;
}
else if( HB_IS_DATE( pItem ) )
{
if( pField->uiType == HB_FT_DATE )
{
hb_itemGetDS( pItem, szBuffer );
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], szBuffer, 8 );
}
else
uiError = EDBF_DATATYPE;
}
else if( HB_IS_NUMBER( pItem ) )
{
if( pField->uiType == HB_FT_LONG )
{
if( hb_itemStrBuf( szBuffer, pItem, pField->uiLen, pField->uiDec ) )
{
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
szBuffer, pField->uiLen );
}
else
{
uiError = EDBF_DATAWIDTH;
memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
'*', pField->uiLen );
}
}
else
uiError = EDBF_DATATYPE;
}
else if( HB_IS_LOGICAL( pItem ) )
{
if( pField->uiType == HB_FT_LOGICAL )
pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] = hb_itemGetL( pItem ) ? 'T' : 'F';
else
uiError = EDBF_DATATYPE;
}
else
uiError = EDBF_DATATYPE;
}
if( uiError != HB_SUCCESS )
{
PHB_ITEM pError= hb_errNew();
USHORT uiGenCode = uiError == EDBF_DATAWIDTH ? EG_DATAWIDTH : EDBF_DATATYPE;
hb_errPutGenCode( pError, uiGenCode );
hb_errPutDescription( pError, hb_langDGetErrorDesc( uiGenCode ) );
hb_errPutOperation( pError, hb_dynsymName( ( PHB_DYNS ) pField->sym ) );
hb_errPutSubCode( pError, uiError );
hb_errPutFlags( pError, EF_CANDEFAULT );
uiError = SELF_ERROR( ( AREAP ) pArea, pError );
hb_itemRelease( pError );
return uiError == E_DEFAULT ? HB_SUCCESS : HB_FAILURE;
}
return HB_SUCCESS;
}
//------------------------------------------------------------------------------
// IEventHandler's Invoke()
// self is where the action happens
// self function receives events (by their ID number) and distributes the processing
// or them or ignores them
static ULONG STDMETHODCALLTYPE Invoke( IEventHandler *self, DISPID dispid, REFIID riid,
LCID lcid, WORD wFlags, DISPPARAMS *params, VARIANT *result, EXCEPINFO *pexcepinfo,
UINT *puArgErr )
{
PHB_ITEM pItem;
int iArg, i;
PHB_ITEM pItemArray[32]; // max 32 parameters?
PHB_ITEM *pItems;
ULONG ulRefMask = 0;
ULONG ulPos;
PHB_ITEM Key;
Key = hb_itemNew( NULL );
// We implement only a "default" interface
if ( !IsEqualIID( riid, &IID_NULL ) )
return( DISP_E_UNKNOWNINTERFACE );
HB_SYMBOL_UNUSED(lcid);
HB_SYMBOL_UNUSED(wFlags);
HB_SYMBOL_UNUSED(result);
HB_SYMBOL_UNUSED(pexcepinfo);
HB_SYMBOL_UNUSED(puArgErr);
// delegate work to somewhere else in PRG
//***************************************
#ifdef __USEHASHEVENTS
if ( hb_hashScan( ((MyRealIEventHandler* ) self)->pEvents, hb_itemPutNL( Key, dispid ),
&ulPos ) )
{
PHB_ITEM pArray = hb_hashGetValueAt( ((MyRealIEventHandler* ) self)->pEvents, ulPos );
#else
ulPos = hb_arrayScan( ((MyRealIEventHandler* ) self)->pEvents, hb_itemPutNL( Key, dispid ),
NULL, NULL, 0
#ifdef __XHARBOUR__
, 0
#endif
);
if ( ulPos )
{
PHB_ITEM pArray = hb_arrayGetItemPtr( ((MyRealIEventHandler* ) self)->pEventsExec, ulPos );
#endif
PHB_ITEM pExec = hb_arrayGetItemPtr( pArray, 01 );
if ( pExec )
{
hb_vmRequestReenter();
switch ( hb_itemType( pExec ) )
{
case HB_IT_BLOCK:
{
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pExec );
break;
}
case HB_IT_STRING:
{
PHB_ITEM pObject = hb_arrayGetItemPtr( pArray, 2 );
hb_vmPushSymbol( hb_dynsymSymbol( hb_dynsymFindName( hb_itemGetCPtr( pExec ) ) ) );
if ( HB_IS_OBJECT( pObject ) )
hb_vmPush( pObject );
else
hb_vmPushNil();
break;
}
case HB_IT_POINTER:
{
hb_vmPushSymbol( hb_dynsymSymbol( ( (PHB_SYMB) pExec ) -> pDynSym ) );
hb_vmPushNil();
break;
}
}
iArg = params->cArgs;
for( i = 1; i<= iArg; i++ )
{
pItem = hb_itemNew(NULL);
hb_oleVariantToItem( pItem, &(params->rgvarg[iArg-i]) );
pItemArray[i-1] = pItem;
// set bit i
ulRefMask |= ( 1L << (i-1) );
}
if( iArg )
{
pItems = pItemArray;
hb_itemPushList( ulRefMask, iArg, &pItems );
}
// execute
hb_vmDo( (USHORT) iArg );
// En caso de que los parametros sean pasados por referencia
for( i=iArg; i > 0; i-- )
{
if( ( (&(params->rgvarg[iArg-i]))->n1.n2.vt & VT_BYREF ) == VT_BYREF )
{
switch( (&(params->rgvarg[iArg-i]))->n1.n2.vt )
{
//case VT_UI1|VT_BYREF:
// *((&(params->rgvarg[iArg-i]))->n1.n2.n3.pbVal) = va_arg(argList,unsigned char*); //pItemArray[i-1]
// break;
case VT_I2|VT_BYREF:
*((&(params->rgvarg[iArg-i]))->n1.n2.n3.piVal) = (short) hb_itemGetNI(pItemArray[i-1]);
break;
case VT_I4|VT_BYREF:
*((&(params->rgvarg[iArg-i]))->n1.n2.n3.plVal) = (long) hb_itemGetNL(pItemArray[i-1]);
break;
case VT_R4|VT_BYREF:
*((&(params->rgvarg[iArg-i]))->n1.n2.n3.pfltVal) = (float) hb_itemGetND(pItemArray[i-1]);
break;
case VT_R8|VT_BYREF:
*((&(params->rgvarg[iArg-i]))->n1.n2.n3.pdblVal) = (double) hb_itemGetND(pItemArray[i-1]);
break;
case VT_BOOL|VT_BYREF:
*((&(params->rgvarg[iArg-i]))->n1.n2.n3.pboolVal) = (VARIANT_BOOL) ( hb_itemGetL( pItemArray[i-1] ) ? 0xFFFF : 0 );
break;
//case VT_ERROR|VT_BYREF:
// *((&(params->rgvarg[iArg-i]))->n1.n2.n3.pscode) = va_arg(argList, SCODE*);
// break;
case VT_DATE|VT_BYREF:
*((&(params->rgvarg[iArg-i]))->n1.n2.n3.pdate) = (DATE) (double) (hb_itemGetDL(pItemArray[i-1])-2415019 );
break;
//case VT_CY|VT_BYREF:
// *((&(params->rgvarg[iArg-i]))->n1.n2.n3.pcyVal) = va_arg(argList, CY*);
// break;
//case VT_BSTR|VT_BYREF:
// *((&(params->rgvarg[iArg-i]))->n1.n2.n3.pbstrVal = va_arg(argList, BSTR*);
// break;
//case VT_UNKNOWN|VT_BYREF:
// pArg->ppunkVal = va_arg(argList, LPUNKNOWN*);
// break;
//case VT_DISPATCH|VT_BYREF:
// pArg->ppdispVal = va_arg(argList, LPDISPATCH*);
// break;
} // EOF switch( (&(params->rgvarg[iArg-i]))->n1.n2.vt )
} // EOF if( (&(params->rgvarg[iArg-i]))->n1.n2.vt & VT_BYREF == VT_BYREF )
} // EOF for( i=iArg; i > 0; i-- )
hb_vmRequestRestore();
} // EOF if ( pExec )
} // EOF If Scan
hb_itemRelease( Key );
return S_OK;
} // EOF invoke
//------------------------------------------------------------------------------
// Here's IEventHandler's VTable. It never changes so we can declare it static
static const IEventHandlerVtbl IEventHandler_Vtbl = {
QueryInterface,
AddRef,
Release,
GetTypeInfoCount,
GetTypeInfo,
GetIDsOfNames,
Invoke
};
//------------------------------------------------------------------------------
// constructor
// params:
// device_interface - refers to the interface type of the COM object (whose event we are trying to receive).
// device_event_interface - indicates the interface type of the outgoing interface supported by the COM object.
// This will be the interface that must be implemented by the Sink object.
// is essentially derived from IDispatch, our Sink object (self IEventHandler)
// is also derived from IDispatch.
typedef IEventHandler device_interface;
// Hash // SetupConnectionPoint( oOle:hObj, @hSink, hEvents ) -> nError
// Array // SetupConnectionPoint( oOle:hObj, @hSink, aEvents, aExecEvent ) -> nError
HB_FUNC( SETUPCONNECTIONPOINT )
{
IConnectionPointContainer* pIConnectionPointContainerTemp = NULL;
IUnknown* pIUnknown = NULL;
IConnectionPoint* m_pIConnectionPoint;
IEnumConnectionPoints* m_pIEnumConnectionPoints;
HRESULT hr; //,r;
IID rriid;
register IEventHandler * selfobj;
DWORD dwCookie = 0;
device_interface* pdevice_interface = (device_interface*) HB_PARNL( 1 );
MyRealIEventHandler* pThis;
// Allocate our IEventHandler object (actually a MyRealIEventHandler)
// intentional misrepresentation of size
selfobj = ( IEventHandler *) GlobalAlloc( GMEM_FIXED, sizeof( MyRealIEventHandler ) );
if ( ! selfobj )
{
hr = E_OUTOFMEMORY;
}
else
{
// Store IEventHandler's VTable in the object
selfobj->lpVtbl = (IEventHandlerVtbl *) &IEventHandler_Vtbl;
// Increment the reference count so we can call Release() below and
// it will deallocate only if there is an error with QueryInterface()
((MyRealIEventHandler *) selfobj)->count = 0;
//((MyRealIEventHandler *) selfobj)->device_event_interface_iid = &riid;
((MyRealIEventHandler *) selfobj)->device_event_interface_iid = IID_IDispatch;
// Query self object itself for its IUnknown pointer which will be used
// later to connect to the Connection Point of the device_interface object.
hr = selfobj->lpVtbl->QueryInterface( selfobj, &IID_IUnknown, (void**) (void *) &pIUnknown );
if ( hr == S_OK && pIUnknown )
{
// Query the pdevice_interface for its connection point.
hr = pdevice_interface->lpVtbl->QueryInterface( pdevice_interface,
&IID_IConnectionPointContainer, (void**) (void *) &pIConnectionPointContainerTemp );
if ( hr == S_OK && pIConnectionPointContainerTemp )
{
// start uncomment
hr = pIConnectionPointContainerTemp->lpVtbl->EnumConnectionPoints( pIConnectionPointContainerTemp, &m_pIEnumConnectionPoints );
if ( hr == S_OK && m_pIEnumConnectionPoints )
{
do
{
hr = m_pIEnumConnectionPoints->lpVtbl->Next( m_pIEnumConnectionPoints, 1, &m_pIConnectionPoint , NULL);
if( hr == S_OK )
{
if ( m_pIConnectionPoint->lpVtbl->GetConnectionInterface( m_pIConnectionPoint, &rriid ) == S_OK )
{
break;
}
}
} while( hr == S_OK );
m_pIEnumConnectionPoints->lpVtbl->Release(m_pIEnumConnectionPoints);
}
// end uncomment
//hr = pIConnectionPointContainerTemp ->lpVtbl->FindConnectionPoint(pIConnectionPointContainerTemp , &IID_IDispatch, &m_pIConnectionPoint);
pIConnectionPointContainerTemp->lpVtbl->Release( pIConnectionPointContainerTemp );
pIConnectionPointContainerTemp = NULL;
}
if ( hr == S_OK && m_pIConnectionPoint )
{
//OutputDebugString("getting iid");
//Returns the IID of the outgoing interface managed by self connection point.
//hr = m_pIConnectionPoint->lpVtbl->GetConnectionInterface(m_pIConnectionPoint, &rriid );
//OutputDebugString("called");
if( hr == S_OK )
{
((MyRealIEventHandler *) selfobj)->device_event_interface_iid = rriid;
}
else
OutputDebugString("error getting iid");
//OutputDebugString("calling advise");
hr = m_pIConnectionPoint->lpVtbl->Advise( m_pIConnectionPoint, pIUnknown, &dwCookie );
((MyRealIEventHandler *) selfobj)->pIConnectionPoint = m_pIConnectionPoint;
((MyRealIEventHandler *) selfobj)->dwEventCookie = dwCookie;
}
pIUnknown->lpVtbl->Release(pIUnknown);
pIUnknown = NULL;
}
}
if( selfobj )
{
pThis = (MyRealIEventHandler *) selfobj;
#ifndef __USEHASHEVENTS
pThis->pEventsExec = hb_itemNew( hb_param( 4, HB_IT_ANY ) );
#endif
pThis->pEvents = hb_itemNew( hb_param( 3, HB_IT_ANY ) );
HB_STORNL2( (LONG_PTR) pThis, 2 );
}
HWNDret( hr );
}
//------------------------------------------------------------------------------
HB_FUNC( SHUTDOWNCONNECTIONPOINT )
{
MyRealIEventHandler *self = ( MyRealIEventHandler * ) HB_PARNL( 1 );
if( self->pIConnectionPoint )
{
self->pIConnectionPoint->lpVtbl->Unadvise( self->pIConnectionPoint, self->dwEventCookie );
self->dwEventCookie = 0;
self->pIConnectionPoint->lpVtbl->Release( self->pIConnectionPoint );
self->pIConnectionPoint = NULL;
}
}
//------------------------------------------------------------------------------
HB_FUNC( RELEASEDISPATCH )
{
IDispatch * pObj;
pObj = ( IDispatch * ) HWNDparam( 1 );
pObj->lpVtbl->Release( pObj );
}
/* Export DBF content to a SQL script file */
static HB_ULONG hb_db2Sql( AREAP pArea, PHB_ITEM pFields, HB_MAXINT llNext,
PHB_ITEM pWhile, PHB_ITEM pFor,
const char * szDelim, const char * szSep,
const char * szEsc, const char * szTable,
HB_FHANDLE hFile, HB_BOOL fInsert, HB_BOOL fRecno )
{
PHB_FILEBUF pFileBuf;
HB_ULONG ulRecords = 0;
HB_USHORT uiFields = 0, ui;
PHB_ITEM pTmp;
HB_BOOL fWriteSep = HB_FALSE;
const char * szNewLine = hb_conNewLine();
char * szInsert = NULL;
HB_BOOL fEof = HB_TRUE;
HB_BOOL fNoFieldPassed = ( pFields == NULL || hb_arrayLen( pFields ) == 0 );
if( SELF_FIELDCOUNT( pArea, &uiFields ) != HB_SUCCESS )
return 0;
if( fInsert && szTable )
szInsert = hb_xstrcpy( NULL, "INSERT INTO ", szTable, " VALUES ( ", NULL );
pFileBuf = hb_createFBuffer( hFile, HB_FILE_BUF_SIZE );
pTmp = hb_itemNew( NULL );
while( llNext-- > 0 )
{
if( pWhile )
{
if( SELF_EVALBLOCK( pArea, pWhile ) != HB_SUCCESS ||
! hb_itemGetL( pArea->valResult ) )
break;
}
if( SELF_EOF( pArea, &fEof ) != HB_SUCCESS || fEof )
break;
if( pFor )
{
if( SELF_EVALBLOCK( pArea, pFor ) != HB_SUCCESS )
break;
}
if( ! pFor || hb_itemGetL( pArea->valResult ) )
{
++ulRecords;
if( szInsert )
hb_addStrToFBuffer( pFileBuf, szInsert );
if( fRecno )
{
HB_ULONG ulRec = ulRecords;
char szRecno[ 13 ], * szVal;
szVal = szRecno + sizeof( szRecno );
*--szVal = 0;
do
{
*--szVal = ( char ) ( ulRec % 10 ) + '0';
ulRec /= 10;
}
while( ulRec );
hb_addStrToFBuffer( pFileBuf, szVal );
hb_addStrToFBuffer( pFileBuf, szSep );
}
if( fNoFieldPassed )
{
for( ui = 1; ui <= uiFields; ui++ )
{
if( SELF_GETVALUE( pArea, ui, pTmp ) != HB_SUCCESS )
break;
if( fWriteSep )
hb_addStrToFBuffer( pFileBuf, szSep );
fWriteSep = hb_exportBufSqlVar( pFileBuf, pTmp, szDelim, szEsc );
}
if( ui <= uiFields )
break;
}
else
{
/* TODO: exporting only some fields */
}
if( szInsert )
hb_addStrToFBuffer( pFileBuf, " );" );
hb_addStrToFBuffer( pFileBuf, szNewLine );
fWriteSep = HB_FALSE;
}
if( SELF_SKIP( pArea, 1 ) != HB_SUCCESS )
break;
if( ( llNext % 10000 ) == 0 )
hb_inkeyPoll();
}
if( szInsert )
hb_xfree( szInsert );
hb_destroyFBuffer( pFileBuf );
hb_itemRelease( pTmp );
/* Writing EOF */
/* hb_fsWrite( hFile, "\x1A", 1 ); */
return ulRecords;
}
/* Export field value into the buffer in SQL format */
static HB_BOOL hb_exportBufSqlVar( PHB_FILEBUF pFileBuf, PHB_ITEM pValue,
const char * szDelim, const char * szEsc )
{
switch( hb_itemType( pValue ) )
{
case HB_IT_STRING:
{
HB_SIZE nLen = hb_itemGetCLen( pValue );
HB_SIZE nCnt = 0;
const char *szVal = hb_itemGetCPtr( pValue );
hb_addStrToFBuffer( pFileBuf, szDelim );
while( nLen && HB_ISSPACE( szVal[ nLen - 1 ] ) )
nLen--;
while( *szVal && nCnt++ < nLen )
{
if( *szVal == *szDelim || *szVal == *szEsc )
hb_addToFBuffer( pFileBuf, *szEsc );
if( ( HB_UCHAR ) *szVal >= 32 )
hb_addToFBuffer( pFileBuf, *szVal );
else
{
/* printf( "%d %c", *szVal, *szVal ); */
}
szVal++;
}
hb_addStrToFBuffer( pFileBuf, szDelim );
break;
}
case HB_IT_DATE:
{
char szDate[ 9 ];
hb_addStrToFBuffer( pFileBuf, szDelim );
hb_itemGetDS( pValue, szDate );
if( szDate[ 0 ] == ' ' )
{
hb_addStrToFBuffer( pFileBuf, "0100-01-01" );
}
else
{
hb_addStrnToFBuffer( pFileBuf, &szDate[0], 4 );
hb_addToFBuffer( pFileBuf, '-' );
hb_addStrnToFBuffer( pFileBuf, &szDate[4], 2 );
hb_addToFBuffer( pFileBuf, '-' );
hb_addStrnToFBuffer( pFileBuf, &szDate[6], 2 );
}
hb_addStrToFBuffer( pFileBuf, szDelim );
break;
}
case HB_IT_TIMESTAMP:
{
long lDate, lTime;
char szDateTime[ 24 ];
hb_itemGetTDT( pValue, &lDate, &lTime );
hb_timeStampStr( szDateTime, lDate, lTime );
hb_addStrToFBuffer( pFileBuf, szDelim );
hb_addStrToFBuffer( pFileBuf, szDateTime );
hb_addStrToFBuffer( pFileBuf, szDelim );
break;
}
case HB_IT_LOGICAL:
hb_addStrToFBuffer( pFileBuf, szDelim );
hb_addToFBuffer( pFileBuf, hb_itemGetL( pValue ) ? 'Y' : 'N' );
hb_addStrToFBuffer( pFileBuf, szDelim );
break;
case HB_IT_INTEGER:
case HB_IT_LONG:
case HB_IT_DOUBLE:
{
char szResult[ HB_MAX_DOUBLE_LENGTH ];
int iSize, iWidth, iDec;
hb_itemGetNLen( pValue, &iWidth, &iDec );
iSize = ( iDec > 0 ? iWidth + 1 + iDec : iWidth );
if( hb_itemStrBuf( szResult, pValue, iSize, iDec ) )
{
int iPos = 0;
while( iSize && HB_ISSPACE( szResult[ iPos ] ) )
{
iPos++;
iSize--;
}
hb_addStrnToFBuffer( pFileBuf, &szResult[ iPos ], iSize );
}
else
hb_addToFBuffer( pFileBuf, '0' );
break;
}
/* an "M" field or the other, might be a "V" in SixDriver */
default:
/* We do not want MEMO contents */
return HB_FALSE;
}
return HB_TRUE;
}
static int hb_matherrblock( HB_MATH_EXCEPTION * pexc )
{
PHB_MATHERRDATA pMathErr = hb_mathErrData();
int retval;
/* call codeblock for both case: handled and unhandled exceptions */
if( pMathErr->block )
{
PHB_ITEM pArray, pRet;
PHB_ITEM pType, pFuncname, pError, pArg1, pArg2, pRetval, pHandled;
const char * funcname = pexc->funcname;
if( funcname == HB_ERR_FUNCNAME )
{
PHB_SYMB pSym = hb_itemGetSymbol( hb_stackBaseItem() );
if( pSym )
funcname = pSym->szName;
}
pType = hb_itemPutNI( NULL, pexc->type );
pFuncname = hb_itemPutC( NULL, funcname );
pError = hb_itemPutC( NULL, pexc->error );
pArg1 = hb_itemPutND( NULL, pexc->arg1 );
pArg2 = hb_itemPutND( NULL, pexc->arg2 );
pRetval = hb_itemPutNDLen( NULL, pexc->retval, pexc->retvalwidth, pexc->retvaldec );
pHandled = hb_itemPutL( NULL, pexc->handled );
pArray = hb_itemArrayNew( 2 );
hb_itemArrayPut( pArray, 1, pRetval );
hb_itemArrayPut( pArray, 2, pHandled );
/* launch error codeblock that can
a) change the members of the array = {dRetval, lHandled} to set the
return value of the math C RTL routine and the <exception handled
flag> and it
b) can return an integer value to set the return value of matherr().
NOTE that these values are only used if lHandled was .F. and is set
to .T. within the codeblock */
pRet = hb_itemDo( pMathErr->block, 6, pType, pFuncname, pError, pArg1, pArg2, pArray );
hb_itemRelease( pType );
hb_itemRelease( pFuncname );
hb_itemRelease( pError );
hb_itemRelease( pArg1 );
hb_itemRelease( pArg2 );
hb_itemRelease( pRetval );
hb_itemRelease( pHandled );
if( pexc->handled )
{
/* math exception has already been handled, so codeblock call above
was only informative */
retval = 1;
}
else
{
/* exception handled by codeblock ? */
pHandled = hb_itemArrayGet( pArray, 2 );
if( pHandled )
{
pexc->handled = hb_itemGetL( pHandled );
hb_itemRelease( pHandled );
}
if( pexc->handled )
{
/* YES ! */
/* extract retval for math routine and matherr() */
pRetval = hb_itemArrayGet( pArray, 1 );
if( pRetval )
{
pexc->retval = hb_itemGetND( pRetval );
hb_itemGetNLen( pRetval, &pexc->retvalwidth, &pexc->retvaldec );
hb_itemRelease( pRetval );
}
if( pRet && HB_IS_NUMERIC( pRet ) )
{
retval = hb_itemGetNI( pRet ); /* block may also return 0 to force C math lib warnings */
hb_itemRelease( pRet );
}
else
{
retval = 1; /* default return value to suppress C math lib warnings */
}
}
else
{
/* NO ! */
retval = 1;
}
}
hb_itemRelease( pArray );
}
else
{
retval = 1; /* default return value to suppress C math lib warnings */
}
if( pMathErr->prevHandler )
{
if( pexc->handled )
{
/* the error is handled, so simply inform the previous handler */
( *pMathErr->prevHandler )( pexc );
}
else
{
/* else go on error handling within previous handler */
retval = ( *pMathErr->prevHandler )( pexc );
}
}
return retval;
}
BOOL xwt_gtk_base_setprop( PXWT_WIDGET widget, char *prop, PHB_ITEM pValue )
{
BOOL ret = TRUE;
XWT_GTK_BASE *wSelf = (PXWT_GTK_BASE) widget->widget_data;
GtkWidget *wTop = wSelf->top_widget( widget );
GtkWidget *wMain = wSelf->main_widget;
char *szPropVal;
if ( strcmp( prop, "x" ) == 0 )
{
wSelf->x = hb_itemGetNI(pValue);
gtk_widget_set_uposition( wTop, wSelf->x , wSelf->y );
}
else if ( strcmp( prop, "y" ) == 0 )
{
wSelf->y = hb_itemGetNI(pValue);
gtk_widget_set_uposition( wTop, wSelf->x , wSelf->y );
}
else if ( strcmp( prop, "width" ) == 0 )
{
wSelf->width = hb_itemGetNI(pValue);
if ( wSelf->height > 0 )
{
gtk_widget_set_size_request( wTop, wSelf->width , wSelf->height );
}
}
else if ( strcmp( prop, "height" ) == 0 )
{
wSelf->height = hb_itemGetNI(pValue);
if ( wSelf->width > 0 )
{
gtk_widget_set_size_request( wTop, wSelf->width , wSelf->height );
}
}
else if ( strcmp( prop, "id" ) == 0 )
{
wSelf->nId = hb_itemGetNI(pValue);
}
else if ( strcmp( prop, "broadcast" ) == 0 )
{
wSelf->bBroadcast = hb_itemGetL(pValue);
}
else if ( strcmp( prop, "visibility" ) == 0 )
{
szPropVal = hb_itemGetCPtr( pValue );
if( szPropVal == NULL )
{
ret = FALSE;
}
else if ( strcmp( szPropVal, "normal" ) == 0 )
{
gtk_widget_show( wTop );
}
else if ( strcmp( szPropVal, "hidden" ) == 0 )
{
gtk_widget_hide( wTop );
}
else
{
ret = FALSE;
}
}
else if ( strcmp( prop, "focus" ) == 0 )
{
if( hb_itemGetL( pValue ) )
{
gtk_widget_grab_focus( wTop );
}
else
{
ret = FALSE; // can't just give away focus
}
}
// fgcolor
else if ( strcmp( prop, "fgcolor" ) == 0 )
{
GdkColor color;
szPropVal = hb_itemGetCPtr( pValue ) ;
if ( szPropVal )
{
wSelf->fgColor = hb_itemGetCPtr( pValue ) ;
gdk_color_parse (wSelf->fgColor, &color);
switch( widget->type )
{
case XWT_TYPE_TOGGLEBUTTON:
case XWT_TYPE_RADIOBUTTON:
case XWT_TYPE_CHECKBOX:
widget_set_color(wTop, &color,1);
break;
case XWT_TYPE_BUTTON:
case XWT_TYPE_LABEL:
widget_set_color(wMain, &color,1);
break;
}
}
else
{
ret = FALSE ;
}
}
else if ( strcmp( prop, "bgcolor" ) == 0 )
{
GdkColor color;
szPropVal = hb_itemGetCPtr( pValue ) ;
if ( szPropVal )
{
wSelf->bgColor = hb_itemGetCPtr( pValue ) ;
gdk_color_parse (wSelf->bgColor, &color);
// widget_set_color(GTK_LABEL(wMain), &color,2 );
switch( widget->type )
{
case XWT_TYPE_TOGGLEBUTTON:
case XWT_TYPE_RADIOBUTTON:
case XWT_TYPE_CHECKBOX:
widget_set_color(wTop, &color,2);
break;
case XWT_TYPE_BUTTON:
case XWT_TYPE_LABEL:
widget_set_color(wMain, &color,2);
break;
}
}
else
{
ret = FALSE ;
}
}
else if ( strcmp( prop, "textcolor" ) == 0 )
{
GdkColor color;
szPropVal = hb_itemGetCPtr( pValue ) ;
if ( szPropVal )
{
wSelf->textColor = hb_itemGetCPtr( pValue ) ;
gdk_color_parse (wSelf->textColor, &color);
// widget_set_color(GTK_LABEL(wMain), &color,4 );
switch( widget->type )
{
case XWT_TYPE_TOGGLEBUTTON:
case XWT_TYPE_RADIOBUTTON:
case XWT_TYPE_CHECKBOX:
widget_set_color(wTop, &color,4);
break;
case XWT_TYPE_BUTTON:
case XWT_TYPE_LABEL:
widget_set_color(wMain, &color,4);
break;
}
}
else
{
ret = FALSE ;
}
}
else if ( strcmp( prop, "basecolor" ) == 0 )
{
GdkColor color;
szPropVal = hb_itemGetCPtr( pValue ) ;
if ( szPropVal ) {
wSelf->baseColor = hb_itemGetCPtr( pValue ) ;
gdk_color_parse (wSelf->baseColor, &color);
// widget_set_color(GTK_LABEL(wMain), &color,3 );
switch( widget->type )
{
case XWT_TYPE_TOGGLEBUTTON:
case XWT_TYPE_RADIOBUTTON:
case XWT_TYPE_CHECKBOX:
widget_set_color(wTop, &color,3);
break;
case XWT_TYPE_BUTTON:
case XWT_TYPE_LABEL:
widget_set_color(wMain, &color,3);
break;
}
}
else
{
ret = FALSE ;
}
}
else
{
ret = FALSE;
}
return ret;
}
/*
* Assign a value to a field.
*/
static HB_ERRCODE hb_sdfPutValue( SDFAREAP pArea, HB_USHORT uiIndex, PHB_ITEM pItem )
{
char szBuffer[ 256 ];
HB_ERRCODE errCode;
LPFIELD pField;
HB_SIZE nSize;
HB_TRACE( HB_TR_DEBUG, ( "hb_sdfPutValue(%p,%hu,%p)", pArea, uiIndex, pItem ) );
if( ! pArea->fPositioned )
return HB_SUCCESS;
if( ! pArea->fRecordChanged )
return HB_FAILURE;
if( --uiIndex >= pArea->area.uiFieldCount )
return HB_FAILURE;
errCode = HB_SUCCESS;
pField = pArea->area.lpFields + uiIndex;
if( pField->uiType != HB_FT_MEMO && pField->uiType != HB_FT_NONE )
{
if( HB_IS_MEMO( pItem ) || HB_IS_STRING( pItem ) )
{
if( pField->uiType == HB_FT_STRING )
{
if( ( pField->uiFlags & HB_FF_BINARY ) == 0 )
{
nSize = pField->uiLen;
hb_cdpnDup2( hb_itemGetCPtr( pItem ), hb_itemGetCLen( pItem ),
( char * ) pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
&nSize, hb_vmCDP(), pArea->area.cdPage );
}
else
{
nSize = hb_itemGetCLen( pItem );
if( nSize > ( HB_SIZE ) pField->uiLen )
nSize = pField->uiLen;
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
hb_itemGetCPtr( pItem ), nSize );
}
if( nSize < ( HB_SIZE ) pField->uiLen )
memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ] + nSize,
' ', pField->uiLen - nSize );
}
else
errCode = EDBF_DATATYPE;
}
else if( HB_IS_DATETIME( pItem ) )
{
if( pField->uiType == HB_FT_DATE )
{
hb_itemGetDS( pItem, szBuffer );
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], szBuffer, 8 );
}
else if( pField->uiType == HB_FT_TIMESTAMP &&
( pField->uiLen == 12 || pField->uiLen == 23 ) )
{
long lDate, lTime;
hb_itemGetTDT( pItem, &lDate, &lTime );
if( pField->uiLen == 12 )
hb_timeStr( szBuffer, lTime );
else
hb_timeStampStr( szBuffer, lDate, lTime );
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ], szBuffer, pField->uiLen );
}
else
errCode = EDBF_DATATYPE;
}
else if( HB_IS_NUMBER( pItem ) )
{
if( pField->uiType == HB_FT_LONG )
{
if( hb_itemStrBuf( szBuffer, pItem, pField->uiLen, pField->uiDec ) )
{
memcpy( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
szBuffer, pField->uiLen );
}
else
{
errCode = EDBF_DATAWIDTH;
memset( pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
'*', pField->uiLen );
}
}
else
errCode = EDBF_DATATYPE;
}
else if( HB_IS_LOGICAL( pItem ) )
{
if( pField->uiType == HB_FT_LOGICAL )
pArea->pRecord[ pArea->pFieldOffset[ uiIndex ] ] = hb_itemGetL( pItem ) ? 'T' : 'F';
else
errCode = EDBF_DATATYPE;
}
else
errCode = EDBF_DATATYPE;
}
if( errCode != HB_SUCCESS )
{
PHB_ITEM pError = hb_errNew();
HB_ERRCODE errGenCode = errCode == EDBF_DATAWIDTH ? EG_DATAWIDTH : EDBF_DATATYPE;
hb_errPutGenCode( pError, errGenCode );
hb_errPutDescription( pError, hb_langDGetErrorDesc( errGenCode ) );
hb_errPutOperation( pError, hb_dynsymName( ( PHB_DYNS ) pField->sym ) );
hb_errPutSubCode( pError, errCode );
hb_errPutFlags( pError, EF_CANDEFAULT );
errCode = SELF_ERROR( &pArea->area, pError );
hb_itemRelease( pError );
return errCode == E_DEFAULT ? HB_SUCCESS : HB_FAILURE;
}
return HB_SUCCESS;
}
static PHB_SOCKEX s_sockexNext( PHB_SOCKEX pSock, PHB_ITEM pParams )
{
PHB_SOCKEX pSockNew = NULL;
if( pSock )
{
HB_BOOL fDecompressIn = HB_TRUE, fCompressOut = HB_TRUE;
int level = HB_ZLIB_COMPRESSION_DEFAULT,
strategy = HB_ZLIB_STRATEGY_DEFAULT,
windowBitsIn = MAX_WBITS, windowBitsOut = MAX_WBITS;
if( pParams && HB_IS_HASH( pParams ) )
{
PHB_ITEM pItem;
if( ( pItem = hb_hashGetCItemPtr( pParams, "zlib" ) ) != NULL &&
HB_IS_NUMERIC( pItem ) )
level = hb_itemGetNI( pItem );
if( ( pItem = hb_hashGetCItemPtr( pParams, "zs" ) ) != NULL &&
HB_IS_NUMERIC( pItem ) )
strategy = hb_itemGetNI( pItem );
if( ( pItem = hb_hashGetCItemPtr( pParams, "gzin" ) ) != NULL &&
HB_IS_LOGICAL( pItem ) )
{
fDecompressIn = hb_itemGetL( pItem );
if( fDecompressIn )
windowBitsIn += 16;
}
if( ( pItem = hb_hashGetCItemPtr( pParams, "zin" ) ) != NULL &&
HB_IS_LOGICAL( pItem ) )
{
if( windowBitsIn == MAX_WBITS )
fDecompressIn = hb_itemGetL( pItem );
else if( hb_itemGetL( pItem ) )
windowBitsIn += 16;
}
if( ( pItem = hb_hashGetCItemPtr( pParams, "gzout" ) ) != NULL &&
HB_IS_LOGICAL( pItem ) )
{
fCompressOut = hb_itemGetL( pItem );
if( fCompressOut )
windowBitsOut += 16;
}
if( ( pItem = hb_hashGetCItemPtr( pParams, "zout" ) ) != NULL &&
HB_IS_LOGICAL( pItem ) && windowBitsOut == MAX_WBITS )
fCompressOut = hb_itemGetL( pItem );
}
if( level != HB_ZLIB_COMPRESSION_DISABLE &&
( fDecompressIn || fCompressOut ) )
{
PHB_SOCKEX_Z pZ = ( PHB_SOCKEX_Z ) hb_xgrabz( sizeof( HB_SOCKEX_Z ) );
pSockNew = ( PHB_SOCKEX ) hb_xgrabz( sizeof( HB_SOCKEX ) );
pSockNew->sd = HB_NO_SOCKET;
pSockNew->fRedirAll = HB_TRUE;
pSockNew->pFilter = &s_sockFilter;
pSockNew->cargo = ( void * ) pZ;
pZ->z_read.zalloc = s_zsock_zalloc;
pZ->z_read.zfree = s_zsock_zfree;
pZ->z_read.opaque = Z_NULL;
pZ->z_write.zalloc = s_zsock_zalloc;
pZ->z_write.zfree = s_zsock_zfree;
pZ->z_write.opaque = Z_NULL;
pZ->z_read.next_in = NULL;
pZ->z_read.avail_in = 0;
if( level != Z_DEFAULT_COMPRESSION &&
!( level >= Z_NO_COMPRESSION && level <= Z_BEST_COMPRESSION ) )
level = Z_DEFAULT_COMPRESSION;
if( strategy != Z_FILTERED &&
#if defined( Z_RLE )
strategy != Z_RLE &&
#endif
#if defined( Z_FIXED )
strategy != Z_FIXED &&
#endif
strategy != Z_HUFFMAN_ONLY )
strategy = Z_DEFAULT_STRATEGY;
if( fDecompressIn && level != HB_ZLIB_COMPRESSION_DISABLE )
{
/* MAX_WBITS=15, decompression - support for formats:
* -15: raw, 15: ZLIB, 31: GZIP, 47: ZLIB+GZIP
*/
if( inflateInit2( &pZ->z_read, windowBitsIn ) == Z_OK )
{
pZ->fDecompressIn = HB_TRUE;
pZ->rdbuf = ( HB_BYTE * ) hb_xgrab( HB_ZSOCK_RDBUFSIZE );
}
else
level = HB_ZLIB_COMPRESSION_DISABLE;
}
if( fCompressOut && level != HB_ZLIB_COMPRESSION_DISABLE )
{
/* MAX_WBITS=15, compression format:
* -15: raw, 15: ZLIB (+6 bytes), 31: GZIP(+18 bytes)
*/
if( deflateInit2( &pZ->z_write, level,
Z_DEFLATED, windowBitsOut, HB_ZSOCK_MEM_LEVEL,
strategy ) == Z_OK )
{
pZ->fCompressOut = HB_TRUE;
pZ->wrbuf = ( HB_BYTE * ) hb_xgrab( HB_ZSOCK_WRBUFSIZE );
pZ->z_write.next_out = ( Bytef * ) pZ->wrbuf;
pZ->z_write.avail_out = HB_ZSOCK_WRBUFSIZE;
}
else
level = HB_ZLIB_COMPRESSION_DISABLE;
}
if( level != HB_ZLIB_COMPRESSION_DISABLE )
{
pSockNew->sd = pSock->sd;
pSockNew->fShutDown = pSock->fShutDown;
pSockNew->iAutoFlush = pSock->iAutoFlush;
pZ->sock = pSock;
hb_socekxParamsInit( pSockNew, pParams );
}
else
{
s_sockexClose( pSockNew, HB_FALSE );
pSockNew = NULL;
}
}
}
return pSockNew;
}
static void _hb_jsonEncode( PHB_ITEM pValue, PHB_JSON_ENCODE_CTX pCtx,
HB_SIZE nLevel, HB_BOOL fEOL )
{
/* Protection against recursive structures */
if( ( HB_IS_ARRAY( pValue ) || HB_IS_HASH( pValue ) ) && hb_itemSize( pValue ) > 0 )
{
void * id = HB_IS_HASH( pValue ) ? hb_hashId( pValue ) : hb_arrayId( pValue );
HB_SIZE nIndex;
for( nIndex = 0; nIndex < nLevel; nIndex++ )
{
if( pCtx->pId[ nIndex ] == id )
{
if( ! fEOL && pCtx->fHuman )
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
_hb_jsonCtxAdd( pCtx, "null", 4 );
return;
}
}
if( nLevel >= pCtx->nAllocId )
{
pCtx->nAllocId += 8;
pCtx->pId = ( void ** ) hb_xrealloc( pCtx->pId, sizeof( void * ) * pCtx->nAllocId );
}
pCtx->pId[ nLevel ] = id;
}
if( fEOL )
{
--pCtx->pHead;
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
}
if( HB_IS_STRING( pValue ) )
{
const char * szString = hb_itemGetCPtr( pValue );
HB_SIZE nPos, nPos2, nLen = hb_itemGetCLen( pValue );
_hb_jsonCtxAdd( pCtx, "\"", 1 );
nPos = 0;
while( nPos < nLen )
{
nPos2 = nPos;
while( *( ( const unsigned char * ) szString + nPos2 ) >= ' ' &&
szString[ nPos2 ] != '\\' && szString[ nPos2 ] != '\"' )
nPos2++;
if( nPos2 > nPos )
{
_hb_jsonCtxAdd( pCtx, szString + nPos, nPos2 - nPos );
nPos = nPos2;
continue;
}
switch( szString[ nPos ] )
{
case '\\':
_hb_jsonCtxAdd( pCtx, "\\\\", 2 );
break;
case '\"':
_hb_jsonCtxAdd( pCtx, "\\\"", 2 );
break;
case '\b':
_hb_jsonCtxAdd( pCtx, "\\b", 2 );
break;
case '\f':
_hb_jsonCtxAdd( pCtx, "\\f", 2 );
break;
case '\n':
_hb_jsonCtxAdd( pCtx, "\\n", 2 );
break;
case '\r':
_hb_jsonCtxAdd( pCtx, "\\r", 2 );
break;
case '\t':
_hb_jsonCtxAdd( pCtx, "\\t", 2 );
break;
default:
{
char buf[ 8 ];
hb_snprintf( buf, sizeof( buf ), "\\u00%02X", ( unsigned char ) szString[ nPos ] );
_hb_jsonCtxAdd( pCtx, buf, 6 );
break;
}
}
nPos++;
}
_hb_jsonCtxAdd( pCtx, "\"", 1 );
}
else if( HB_IS_NUMINT( pValue ) )
{
char buf[ 32 ];
hb_snprintf( buf, sizeof( buf ), "%" PFHL "d", hb_itemGetNInt( pValue ) );
_hb_jsonCtxAdd( pCtx, buf, strlen( buf ) );
}
else if( HB_IS_NUMERIC( pValue ) )
{
char buf[ 64 ];
int iDec;
double dblValue = hb_itemGetNDDec( pValue, &iDec );
hb_snprintf( buf, sizeof( buf ), "%.*f", iDec, dblValue );
_hb_jsonCtxAdd( pCtx, buf, strlen( buf ) );
}
else if( HB_IS_NIL( pValue ) )
{
_hb_jsonCtxAdd( pCtx, "null", 4 );
}
else if( HB_IS_LOGICAL( pValue ) )
{
if( hb_itemGetL( pValue ) )
_hb_jsonCtxAdd( pCtx, "true", 4 );
else
_hb_jsonCtxAdd( pCtx, "false", 5 );
}
else if( HB_IS_DATE( pValue ) )
{
char szBuffer[ 10 ];
hb_itemGetDS( pValue, szBuffer + 1 );
szBuffer[ 0 ] = '\"';
szBuffer[ 9 ] = '\"';
_hb_jsonCtxAdd( pCtx, szBuffer, 10 );
}
else if( HB_IS_TIMESTAMP( pValue ) )
{
char szBuffer[ 19 ];
hb_itemGetTS( pValue, szBuffer + 1 );
szBuffer[ 0 ] = '\"';
szBuffer[ 18 ] = '\"';
_hb_jsonCtxAdd( pCtx, szBuffer, 19 );
}
else if( HB_IS_ARRAY( pValue ) )
{
HB_SIZE nLen = hb_itemSize( pValue );
if( nLen )
{
HB_SIZE nIndex;
if( pCtx->fHuman )
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
_hb_jsonCtxAdd( pCtx, "[", 1 );
for( nIndex = 1; nIndex <= nLen; nIndex++ )
{
PHB_ITEM pItem = hb_arrayGetItemPtr( pValue, nIndex );
if( nIndex > 1 )
_hb_jsonCtxAdd( pCtx, ",", 1 );
if( pCtx->fHuman )
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
if( pCtx->fHuman &&
! ( ( HB_IS_ARRAY( pItem ) || HB_IS_HASH( pItem ) ) &&
hb_itemSize( pItem ) > 0 ) )
_hb_jsonCtxAddIndent( pCtx, ( nLevel + 1 ) * INDENT_SIZE );
_hb_jsonEncode( pItem, pCtx, nLevel + 1, HB_FALSE );
}
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
}
_hb_jsonCtxAdd( pCtx, "]", 1 );
}
else
_hb_jsonCtxAdd( pCtx, "[]", 2 );
}
else if( HB_IS_HASH( pValue ) )
{
HB_SIZE nLen = hb_hashLen( pValue );
if( nLen )
{
HB_SIZE nIndex;
if( pCtx->fHuman )
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
_hb_jsonCtxAdd( pCtx, "{", 1 );
for( nIndex = 1; nIndex <= nLen; nIndex++ )
{
PHB_ITEM pKey = hb_hashGetKeyAt( pValue, nIndex );
if( HB_IS_STRING( pKey ) )
{
PHB_ITEM pItem = hb_hashGetValueAt( pValue, nIndex );
HB_BOOL fEOL = HB_FALSE;
if( nIndex > 1 )
_hb_jsonCtxAdd( pCtx, ",", 1 );
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
_hb_jsonCtxAddIndent( pCtx, ( nLevel + 1 ) * INDENT_SIZE );
}
_hb_jsonEncode( pKey, pCtx, nLevel + 1, HB_FALSE );
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, ": ", 2 );
fEOL = ( HB_IS_ARRAY( pItem ) || HB_IS_HASH( pItem ) ) && hb_itemSize( pItem ) > 0;
}
else
_hb_jsonCtxAdd( pCtx, ":", 1 );
_hb_jsonEncode( pItem, pCtx, nLevel + 1, fEOL );
}
}
if( pCtx->fHuman )
{
_hb_jsonCtxAdd( pCtx, pCtx->szEol, pCtx->iEolLen );
_hb_jsonCtxAddIndent( pCtx, nLevel * INDENT_SIZE );
}
_hb_jsonCtxAdd( pCtx, "}", 1 );
}
else
_hb_jsonCtxAdd( pCtx, "{}", 2 );
}
else
{
/* All unsupported types are replacd by null */
_hb_jsonCtxAdd( pCtx, "null", 4 );
}
}
//-----------------------------------------------------------------------=
// ÚÄ1ra Col.a Pintar
// ³
static void near PaintTheLine( HDC hDC, RECT * rct, WORD wIndex,
PCLIPVAR pAtext, PCLIPVAR pAsizes,
HPEN hWhitePen, HPEN hGrayPen, BOOL bTree,
PCLIPVAR pAJustify, WORD wPressed,
BOOL bHeader, WORD nStyle,
WORD wFocus, BOOL bFocused,
PCLIPVAR pTextColor, PCLIPVAR pBkColor,
WORD wRowPos, WORD nHeightCtrl,
LONG nClrLine, BOOL bFooter,
BOOL bSelect, PCLIPVAR pFont,
BOOL bDrawFocusRect )
{
RECT box, wholebox, rctadj;
int iMaxRight = rct->right;
WORD wLenJust = 0 ;
#ifndef __HARBOUR__
WORD wLen = _VARRAYLEN( pAtext );
CLV_WORD lJustify;
#else
WORD wLen = hb_arrayLen( pAtext );
PHB_ITEM uElem = hb_itemNew( NULL );
#endif
WORD wType, wcLen;
LONG lValue;
char * cValue;
HPEN hOldPen, hPen;
BITMAP bmp;
WORD wRow, wCol;
LONG lColor ;
HBRUSH hBrush;
LONG lTextColorOld = -1 ; // CeSoTech
LONG lBkColorOld = -1 ; // CeSoTech
PCLIPVAR pEvalOld ;
HFONT hFont ; // CeSoTech
WORD wAlign ; // CeSoTech
// CeSoTech
LONG nClrLineC = ( nStyle == 2 || nStyle == 6 || nStyle == 8 ||
nStyle == 10 ) ? GetSysColor( COLOR_BTNSHADOW ) : 0 ;
// CeSoTech
if ( nClrLine >= 0 ) // Desde Clipper manda color especifico linea
nClrLineC = nClrLine ;
if ( ! bDrawHeaders )
bHeader = FALSE ;
if ( bFooter )
bHeader = TRUE ; //-> Para que lo pinte con similar aspecto
//CeSoTech
// Si es un estilo sin separadores horizontales, pintar uno mas arriba
//CeSoTech para que que bien completa el area !!!
if ( ! (bHeader) && (nStyle == 0 || nStyle == 5 || nStyle == 6 ||
nStyle == 9 || nStyle == 10) )
rct->top-- ;
wholebox.top = rct->top+1;
wholebox.left = rct->left;
wholebox.bottom = rct->bottom;
wholebox.right = rct->right;
rct->right = 0;
box.top = rct->top ;
box.bottom = rct->bottom - 1;
if( !wIndex | wIndex > wLen )
wIndex = 1;
if ( pAJustify )
#ifndef __HARBOUR__
wLenJust = _VARRAYLEN( pAJustify );
#else
wLenJust = hb_arrayLen( pAJustify );
#endif
while( wIndex <= wLen )
{
rct->left = rct->right;
rct->right = ( wIndex == wLen ? iMaxRight
: rct->left + GetInt( pAsizes, wIndex ) );
// CeSoTech // Cuando estoy estoy en la ultima celda, NO pintar hasta
// el final si no existe ajuste de ultima columna.
if ( ( wIndex == wLen ) && ( ! bAdjLastCol ) )
{
rct->right = rct->left + GetInt( pAsizes, wIndex ) +(bHeader ? 1: 0) ;
if ( !bAdjBrowse )
wholebox.right = rct->right ; // Tambien ajusto el borde focus
}
// CeSoTech //
wAlign = HA_LEFT | VA_CENTER ; // Alineacion por defecto
wcLen = 0;
///////// INICIO Toma de datos celda !!!
#ifndef __HARBOUR__
if ( wIndex <= wLenJust )
{
_cAt( pAJustify, wIndex, 0xFFFF, ( PCLIPVAR ) &lJustify );
wAlign = lJustify.wWord ;
}
_cAt( pAtext, wIndex, 0xFFFF, ++_tos );
wType = _tos->wType;
if ( wType & NUMERIC )
lValue = (LONG) _tos->pPointer1;
if ( wType & CHARACTER )
{
cValue = _VSTR( _tos );
wcLen = _tos->w2;
}
#else
if ( wIndex <= wLenJust )
{
hb_arrayGet( pAJustify, wIndex, uElem );
if ( ( hb_itemType( uElem ) & LOGICAL ) && hb_itemGetL( uElem ) )
wAlign = HA_RIGHT | VA_CENTER ;
else
wAlign = hb_itemGetNL( uElem );
hb_itemClear( uElem );
}
// uElem.type = HB_IT_NIL;
hb_arrayGet( pAtext, wIndex, uElem );
wType = hb_itemType( uElem );
if ( wType & NUMERIC )
lValue = hb_itemGetNL( uElem );
if ( wType & CHARACTER )
{
// cValue = hb_itemGetC( uElem );
cValue = hb_itemGetCPtr( uElem );
wcLen = strlen( cValue );
}
#endif
///////// FIN Toma de datos celda !!!
if( wFocus > 0 && wIndex != wFocus )
{
#ifndef __HARBOUR__
_tos--;
#endif
if( rct->right >= iMaxRight )
{
wIndex = wLen + 1; // ya no pintamos m s
}
else
++wIndex;
continue;
}
if( bTree ||
(GetInt( pAsizes, wIndex ) > 0) ) //Si NO es columna oculta (x Freeze)
{ //(Es lo mismo no hacer esto,
// pero es para evitar hacer trabajar
// al codigo sin sentido !!! )
if( (wType & NUMERIC) && bTree )
{
if( lValue )
{
FillRect( hDC, rct, hBrush = CreateSolidBrush( GetPixel( hDC, rct->left, rct->top ) ) );
DrawMasked( hDC, (HBITMAP) lValue, rct->top, rct->left );
DeleteObject( hBrush );
}
}
else // Si es Numerico Bmp no Tree, o , es Character !!!!
{
if ( pBkColor ) // Bloque de Color Fondo Celda
{
_PutSym( _SymEval );
_xPushM( pBkColor );
_PutLN( wRowPos );
_PutLN( wIndex );
_PutLN( bFooter ? 2 : ( bHeader ? 1 : ( bSelect ? 3 : 0 ) ) );
_xEval( 3 ) ;
if ( _parinfo( -1 ) & NUMERIC )
lBkColorOld = SetBkColor( hDC, _parnl( - 1 ) ) ;
}
if( pTextColor ) // Bloque de Color Texto Celda
{
_PutSym( _SymEval );
_xPushM( pTextColor );
_PutLN( wRowPos );
_PutLN( wIndex );
_PutLN( bFooter ? 2 : ( bHeader ? 1 : ( bSelect ? 3 : 0 ) ) );
_xEval( 3 ) ;
if ( _parinfo( -1 ) & NUMERIC )
lTextColorOld = SetTextColor( hDC, _parnl( - 1 ) ) ;
}
hFont = 0 ;
if( pFont ) // Bloque de Font Celda
{
_PutSym( _SymEval );
_xPushM( pFont );
_PutLN( wRowPos );
_PutLN( wIndex );
_PutLN( bFooter ? 2 : ( bHeader ? 1 : ( bSelect ? 3 : 0 ) ) );
_xEval( 3 ) ;
if ( _parinfo( -1 ) & NUMERIC )
hFont = (HFONT) _parnl( - 1 ) ;
}
/////// CeSoTech ///////
if (!bHeader) rct->top ++;
if( wType & NUMERIC ) // Es un BitMap
{
FW_DrawBitmapCenter( hDC, (HBITMAP) lValue, rct, nStyle, bSelect );
}
else // Es una Cadena
{
FW_DrawText( hDC, rct,
( wType & CHARACTER ) ? cValue : "",
wAlign, wcLen, hFont, bHeader ) ;
}
/////// CeSoTech restauracion de colores //////
if ( lTextColorOld >= 0 )
{
SetTextColor( hDC, lTextColorOld ) ;
lTextColorOld = -1 ;
}
if ( lBkColorOld >= 0 )
{
SetBkColor( hDC, lBkColorOld ) ;
lBkColorOld = -1 ;
}
/// CeSoTech ///
// Si hay modalidad ajustar el Browse y no hay ajuste de ultima
// columna, deber‚ pintar hasta el final hasta cubrir toda
// el area, hasta llegar a la derecha del control. (Col.Ficticia)
if ( bAdjBrowse && wIndex == wLen && !bAdjLastCol &&
rct->right <= iMaxRight )
{
rctadj.top = rct->top;
rctadj.left = rct->right ;
rctadj.bottom = rct->bottom;
rctadj.right = wholebox.right ;
if ( nStyle == 3 )
rctadj.top--;
if ( wFocus == 0 ) // Si No es CellStyle (Pinto hasta final)
ExtTextOut( hDC, 0, rct->top, ETO_OPAQUE, &rctadj, "", 0, 0 );
if ( bHeader && nStyle==3 ) // Pinto Bordes Header Falso
{
rctadj.right = wholebox.right - 2 ;
rctadj.bottom = rctadj.bottom - 2 ;
WndDrawBox( hDC, &rctadj, hWhitePen, hGrayPen );
rctadj.bottom++ ;
rctadj.right++ ;
WndDrawBox( hDC, &rctadj, hWhitePen, GetStockObject( BLACK_PEN ) );
if ( bFooter ) // Si es Footer (Linea Negra de Arriba Foot)
{
hPen = GetStockObject( BLACK_PEN );
hOldPen = SelectObject( hDC, hPen );
MoveTo( hDC, rctadj.left-1, rctadj.top-1 );
LineTo( hDC, rctadj.right+1, rctadj.top-1 );
SelectObject( hDC, hOldPen );
}
}
}
/// CeSoTech Fin ///
if (!bHeader) rct->top --;
}
box.left = rct->left;
box.right = ( wIndex < wLen && rct->right <= iMaxRight ?
rct->right - 1 :
iMaxRight - 1 );
// CeSoTech // El Borde derecho de Box de la ultima columna,
// no estirarlo cuando no exista ajuste de ultima columna
// PERO cuando nLineStyle (nStyle) es 7/8 (Lineas Horiz)
// queda anti-estetico cortar los renglones, cuando no hay
// ajuste ult.col. y hay ajuste de browse. Por ello
// se verificara que para cortar el borde no se de esta
// condicion.
if ( ( wIndex == wLen ) && ( ! bAdjLastCol ) )
{
if (! (!bHeader && (nStyle==7 || nStyle==8) && !bAdjLastCol && bAdjBrowse) )
box.right = rct->left + GetInt( pAsizes, wIndex ) - 1 ;
}
// CeSoTech //
if( ! bTree )
{
if( wPressed && ( wIndex == wPressed ) )
{
WndDrawBox( hDC, &box, hGrayPen, hWhitePen );
}
else
///////////// if(!bHeader)
if(!bHeader || (bHeader && nStyle!=3) )
{
switch( nStyle )
{
case 0:
break;
case 1:
// hOldPen = SelectObject( hDC, GetStockObject( BLACK_PEN ) );
hPen = CreatePen(PS_SOLID, 0, nClrLineC );
hOldPen = SelectObject( hDC, hPen);
MoveTo( hDC, box.left, box.bottom+1 );
LineTo( hDC, box.left, box.top );
LineTo( hDC, box.right+1, box.top );
LineTo( hDC, box.right+1, box.bottom+1 );
LineTo( hDC, box.left, box.bottom+1 );
SelectObject( hDC, hOldPen );
DeleteObject( hPen);
break;
case 2:
hPen = CreatePen(PS_SOLID, 0, nClrLineC );
hOldPen = SelectObject( hDC, hPen);
MoveTo( hDC, box.left, box.bottom+1 );
LineTo( hDC, box.left, box.top );
LineTo( hDC, box.right+1, box.top );
LineTo( hDC, box.right+1, box.bottom+1 );
LineTo( hDC, box.left, box.bottom+1 );
SelectObject( hDC, hOldPen );
DeleteObject( hPen);
break;
case 3:
WndDrawBox( hDC, &box, hWhitePen, hGrayPen );
break;
case 4:
box.bottom ++;
box.right ++;
FrameDot( hDC, &box );
box.bottom --;
box.right --;
break;
case 7:
case 8:
hPen = CreatePen(PS_SOLID, 0, nClrLineC );
hOldPen = SelectObject( hDC, hPen);
MoveTo( hDC, box.left, box.top );
LineTo( hDC, box.right+1, box.top );
MoveTo( hDC, box.right+1, box.bottom+1 );
LineTo( hDC, box.left, box.bottom+1 );
SelectObject( hDC, hOldPen );
DeleteObject( hPen);
break;
case 5:
case 6:
case 9:
case 10:
hPen = CreatePen(PS_SOLID, 0, nClrLineC);
hOldPen = SelectObject( hDC, hPen);
if (box.left>1)
{
MoveTo( hDC, box.left, box.bottom+1 );
LineTo( hDC, box.left, box.top );
}
MoveTo( hDC, box.right+1, box.top );
if ( bDrawFooters && nStyle >= 9 )
{
LineTo( hDC, box.right+1,
nHeightCtrl - (wFooterHeight+1) ) ;
} else {
LineTo( hDC, box.right+1,
nStyle < 9 ? box.bottom+1 : nHeightCtrl );
}
SelectObject( hDC, hOldPen );
DeleteObject( hPen);
break;
}
}
else // Box para Headers !!!
{
box.left ++;
// CeSoTech
if ( bFooter ) // Linea negra sobre el Footer
{
hPen = GetStockObject( BLACK_PEN );
hOldPen = SelectObject( hDC, hPen );
MoveTo( hDC, box.left-1, box.top-1 );
LineTo( hDC, box.right+1, box.top-1 );
SelectObject( hDC, hOldPen );
}
box.right-- ;
box.bottom-- ;
WndDrawBox( hDC, &box, hWhitePen, hGrayPen );
box.bottom++ ;
box.right++ ;
WndDrawBox( hDC, &box, hWhitePen, GetStockObject( BLACK_PEN ) );
box.left --;
}
}
else
{
if( ! ( wType & NUMERIC ) )
{
box.left -= 16;
}
}
// CeSoTech if( bFocused && wFocus > 0 && wIndex == wFocus )
if( bDrawFocusRect && bFocused && wFocus > 0 &&
wIndex == wFocus && nStyle != 3)
{
rct->left++;
rct->top++;
DrawFocusRect( hDC, rct );
rct->left--;
rct->top--;
}
}
#ifndef __HARBOUR__
_tos--;
#endif
if( rct->right >= iMaxRight )
{
wIndex = wLen + 1; // ya no pintamos m s
}
else
++wIndex;
}
if (bDrawFocusRect && !bTree && bFocused && wFocus==0 && nStyle!=3) // CeSoTech
DrawFocusRect( hDC, &wholebox );
hb_itemRelease( uElem );
}
/* Export field values to text file */
static HB_BOOL hb_ExportVar( HB_FHANDLE handle, PHB_ITEM pValue, const char * cDelim, PHB_CODEPAGE cdp )
{
switch( hb_itemType( pValue ) )
{
/* a "C" field */
case HB_IT_STRING:
{
char * szStrEsc;
char * szString;
szStrEsc = hb_strescape( hb_itemGetCPtr( pValue ),
hb_itemGetCLen( pValue ), cDelim );
if( cdp )
hb_cdpnDupLen( szStrEsc, strlen( szStrEsc ), hb_vmCDP(), cdp );
szString = hb_xstrcpy( NULL, cDelim, szStrEsc, cDelim, NULL );
/* FWrite( handle, szString ) */
hb_fsWriteLarge( handle, szString, strlen( szString ) );
/* Orphaned, get rif off it */
hb_xfree( szStrEsc );
hb_xfree( szString );
break;
}
/* a "D" field */
case HB_IT_DATE:
{
char * szDate = ( char * ) hb_xgrab( 9 );
hb_itemGetDS( pValue, szDate );
hb_fsWriteLarge( handle, szDate, strlen( szDate ) );
hb_xfree( szDate );
break;
}
/* an "L" field */
case HB_IT_LOGICAL:
hb_fsWriteLarge( handle, ( hb_itemGetL( pValue ) ? "T" : "F" ), 1 );
break;
/* an "N" field */
case HB_IT_INTEGER:
case HB_IT_LONG:
case HB_IT_DOUBLE:
{
char * szResult = hb_itemStr( pValue, NULL, NULL );
if( szResult )
{
HB_SIZE nLen = strlen( szResult );
const char * szTrimmed = hb_strLTrim( szResult, &nLen );
hb_fsWriteLarge( handle, szTrimmed, strlen( szTrimmed ) );
hb_xfree( szResult );
}
break;
}
/* an "M" field or the other, might be a "V" in SixDriver */
default:
/* We do not want MEMO contents */
return HB_FALSE;
}
return HB_TRUE;
}
/* Export field value into the buffer in PG accepted CSV format */
static HB_BOOL exportBufSqlVar( pgCopyContext * context, PHB_ITEM pValue, const char * szQuote, const char * szEsc )
{
switch( hb_itemType( pValue ) )
{
case HB_IT_STRING:
case HB_IT_MEMO:
{
HB_SIZE nLen = hb_itemGetCLen( pValue );
HB_SIZE nCnt = 0;
const char * szVal = hb_itemGetCPtr( pValue );
if( ! addStrToContext( context, szQuote ) )
return HB_FALSE;
if( context->str_trim )
{
while( nLen && HB_ISSPACE( szVal[ nLen - 1 ] ) )
nLen--;
}
while( *szVal && nCnt++ < nLen )
{
/* if( *szVal == *szDelim || *szVal == *szEsc || *szVal == *szQuote )
we don't need to escape delim in CSV mode,
only the quote and the escape itself */
if( *szVal == *szQuote || *szVal == *szEsc )
if( ! addToContext( context, *szEsc ) )
return HB_FALSE;
if( ( HB_UCHAR ) *szVal >= 32 )
if( ! addToContext( context, *szVal ) )
return HB_FALSE;
szVal++;
}
if( ! addStrToContext( context, szQuote ) )
return HB_FALSE;
break;
}
case HB_IT_DATE:
{
char szDate[ 9 ];
if( ! addStrToContext( context, szQuote ) )
return HB_FALSE;
hb_itemGetDS( pValue, szDate );
if( szDate[ 0 ] == ' ' )
{
if( ! addStrToContext( context, "0100-01-01" ) )
return HB_FALSE;
}
else
{
if( ! addStrnToContext( context, &szDate[ 0 ], 4 ) ||
! addToContext( context, '-' ) ||
! addStrnToContext( context, &szDate[ 4 ], 2 ) ||
! addToContext( context, '-' ) ||
! addStrnToContext( context, &szDate[ 6 ], 2 ) )
return HB_FALSE;
}
if( ! addStrToContext( context, szQuote ) )
return HB_FALSE;
break;
}
case HB_IT_TIMESTAMP:
{
long lDate, lTime;
char szDateTime[ 24 ];
hb_itemGetTDT( pValue, &lDate, &lTime );
hb_timeStampStr( szDateTime, lDate, lTime );
if( ! addStrToContext( context, szQuote ) ||
! addStrToContext( context, szDateTime ) ||
! addStrToContext( context, szQuote ) )
return HB_FALSE;
break;
}
case HB_IT_LOGICAL:
#if 0
if( ! addStrToContext( context, szQuote ) || ! addToContext( context, hb_itemGetL( pValue ) ? 'Y' : 'N' ) || ! addStrToContext( context, szQuote ) )
#endif
if( ! addToContext( context, hb_itemGetL( pValue ) ? 'Y' : 'N' ) )
return HB_FALSE;
break;
case HB_IT_INTEGER:
case HB_IT_LONG:
case HB_IT_DOUBLE:
{
char szResult[ HB_MAX_DOUBLE_LENGTH ];
int iSize, iWidth, iDec;
hb_itemGetNLen( pValue, &iWidth, &iDec );
iSize = ( iDec > 0 ? iWidth + 1 + iDec : iWidth );
if( hb_itemStrBuf( szResult, pValue, iSize, iDec ) )
{
int iPos = 0;
while( iSize && HB_ISSPACE( szResult[ iPos ] ) )
{
iPos++;
iSize--;
}
if( ! addStrnToContext( context, &szResult[ iPos ], iSize ) )
return HB_FALSE;
}
else
if( ! addToContext( context, '0' ) )
return HB_FALSE;
break;
}
/* an "M" field or the other, might be a "V" in SixDriver */
default:
return HB_FALSE;
}
return HB_TRUE;
}
BOOL sql_item2str( sql_item_arg *pItemArg, SQLSYS_INFO *pSysInfo )
{
ULONG lSize = 0L; /* For Temporary values */
char *szText = NULL; /* Temporary buffer */
BOOL bFree = TRUE;
if (!pItemArg)
{
HB_TRACE(HB_TR_DEBUG,(" Invalid Argument -> %p", pItemArg ));
return FALSE;
}
if (!pSysInfo)
{
pSysInfo = (SQLSYS_INFO *) SQLSYS_GETINFO( 0 );
// Valid driver? It has been correctly loaded into memory?
if (!SR_ISVALID_DRIVER(pSysInfo))
{
HB_TRACE(HB_TR_DEBUG,(" Invalid driver !!" ));
return FALSE;
}
}
HB_TRACE(HB_TR_DEBUG,(" ARGUMENT => '%s'", hb_itemTypeStr( pItemArg->pItem ) ));
switch( hb_itemType( pItemArg->pItem ) )
{
case HB_IT_MEMO:
case HB_IT_STRING:
{
HB_TRACE(HB_TR_DEBUG,(" As Text => '%s'", hb_itemGetCPtr( pItemArg->pItem ) ));
lSize = hb_itemGetCLen( pItemArg->pItem );
szText = (*pSysInfo->EscapeString) ( hb_itemGetCPtr( pItemArg->pItem ), &lSize, 0 );
/*
char *szTemp, *szBuff;
szTemp = (*pSysInfo->EscapeString) ( hb_itemGetCPtr( pItemArg->pItem ), &lSize, 0 );
if (szTemp)
{
szText = (char *) hb_xgrab( lSize + 3L ); // chr(0) + 2 separators
szBuff = szText;
*szText = pSysInfo->FieldDelim; szText ++;
memcpy( szText, szTemp, lSize );
szText += lSize;
*szText = pSysInfo->FieldDelim; szText ++;
*szText = '\0';
hb_xfree( szTemp );
}
/***/
break;
}
case HB_IT_LOGICAL:
HB_TRACE(HB_TR_DEBUG,(" As BOOL => %d", (int) hb_itemGetL( pItemArg->pItem ) ));
szText = (hb_itemGetL( pItemArg->pItem ) ? pSysInfo->BoolTrue : pSysInfo->BoolFalse);
lSize = strlen( szText );
bFree = FALSE;
break;
case HB_IT_DATE:
{
int iYear, iMonth, iDay;
hb_dateDecode( hb_itemGetDL( pItemArg->pItem ), &iYear, &iMonth, &iDay );
HB_TRACE(HB_TR_DEBUG,(" As DATE => %04d/%02d/%02d", iYear, iMonth, iDay ));
if (pSysInfo->DateFormat == ESCAPE_FORMAT_DATE_ISO)
{
szText = SQLSYS_DATETOISO( (char *) hb_xgrab(13), iYear, iMonth, iDay, TRUE );
lSize = 12L;
}
break;
}
case HB_IT_INTEGER:
case HB_IT_DOUBLE:
case HB_IT_LONG:
{
szText = hb_itemStr( pItemArg->pItem, NULL, NULL );
HB_TRACE(HB_TR_DEBUG,(" As Number => %s", szText ));
if( szText )
{
ULONG nToSkip = 0L;
while( szText[ nToSkip] == ' ' )
++nToSkip;
/* Rever isto aqui de perto */
if( nToSkip )
memmove( szText, szText + nToSkip, strlen( szText + nToSkip ) + 1 );
lSize = strlen( szText );
HB_TRACE(HB_TR_DEBUG,(" As Text => '%s' -- %lu", szText, lSize ));
}
break;
}
default:
{
szText = (char *) hb_xgrab(5);
*szText = '\0';
strcat( szText, "NULL" );
lSize = strlen( szText );
break;
}
}
if (!szText)
{
HB_TRACE(HB_TR_DEBUG,(" Impossivel converter este valor:" ));
HB_TRACE_ARGS( pItemArg->pItem );
return FALSE;
}
pItemArg->szResult = szText;
pItemArg->ulSize = lSize;
pItemArg->bDestroy = bFree;
return TRUE;
}
