/*
* 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_DYNS hb_dynsymFindNameWithNamespaces( const char * szName, const char *pNamespaces )
{
if( pNamespaces )
{
char *szNamespace = (char *) pNamespaces;
PHB_DYNS pDynSym;
char szUprName[ HB_SYMBOL_NAME_LEN + 1 ];
{
int iLen = HB_SYMBOL_NAME_LEN;
char * pDest = szUprName;
do
{
char cChar = *szName++;
if( cChar == 0 || cChar == ' ' || cChar == '\t' )
break;
else if( cChar >= 'a' && cChar <= 'z' )
*pDest++ = cChar - ( 'a' - 'A' );
else
*pDest++ = cChar;
}
while( --iLen );
*pDest = '\0';
}
while ( *szNamespace )
{
char *szQualified = hb_xstrcpy( NULL, szNamespace, ".", szUprName, NULL );
pDynSym = hb_dynsymFindName( szQualified );
hb_xfree( szQualified );
if( pDynSym )
{
return pDynSym;
}
szNamespace += strlen( szNamespace ) + 1;
}
return NULL;
}
else
{
return hb_dynsymFindName( szName );
}
}
PHB_ITEM hb_itemDoC( const char * szFunc, HB_ULONG ulPCount, ... )
{
PHB_ITEM pResult = NULL;
HB_TRACE( HB_TR_DEBUG, ( "hb_itemDoC(%s, %lu, ...)", szFunc, ulPCount ) );
if( szFunc )
{
PHB_DYNS pDynSym = hb_dynsymFindName( szFunc );
if( pDynSym )
{
if( hb_vmRequestReenter() )
{
hb_vmPushSymbol( pDynSym->pSymbol );
hb_vmPushNil();
if( ulPCount )
{
HB_ULONG ulParam;
va_list va;
va_start( va, ulPCount );
for( ulParam = 1; ulParam <= ulPCount; ulParam++ )
hb_vmPush( va_arg( va, PHB_ITEM ) );
va_end( va );
}
hb_vmProc( ( HB_USHORT ) ulPCount );
pResult = hb_itemNew( hb_stackReturnItem() );
hb_vmRequestRestore();
}
}
}
return pResult;
}
PHB_ITEM hb_evalLaunch( PHB_EVALINFO pEvalInfo )
{
PHB_ITEM pResult = NULL;
HB_TRACE( HB_TR_DEBUG, ( "hb_evalLaunch(%p)", pEvalInfo ) );
if( pEvalInfo )
{
PHB_ITEM pItem = pEvalInfo->pItems[ 0 ];
PHB_SYMB pSymbol = NULL;
if( HB_IS_STRING( pItem ) )
{
PHB_DYNS pDynSym = hb_dynsymFindName( pItem->item.asString.value );
if( pDynSym )
{
pSymbol = pDynSym->pSymbol;
pItem = NULL;
}
}
else if( HB_IS_SYMBOL( pItem ) )
{
pSymbol = pItem->item.asSymbol.value;
pItem = NULL;
}
else if( HB_IS_BLOCK( pItem ) )
{
pSymbol = &hb_symEval;
}
if( pSymbol )
{
HB_USHORT uiParam = 0;
hb_vmPushSymbol( pSymbol );
if( pItem )
hb_vmPush( pItem );
else
hb_vmPushNil();
while( uiParam < pEvalInfo->paramCount )
hb_vmPush( pEvalInfo->pItems[ ++uiParam ] );
if( pItem )
hb_vmSend( uiParam );
else
hb_vmProc( uiParam );
pResult = hb_itemNew( hb_stackReturnItem() );
}
}
return pResult;
}
static char * sz_callhrb_i( char * szName, int iParam1 )
{
PHB_DYNS pSym_onEvent = hb_dynsymFindName( szName );
if( pSym_onEvent )
{
hb_vmPushSymbol( hb_dynsymSymbol( pSym_onEvent ) );
hb_vmPushNil();
hb_vmPushInteger( iParam1 );
hb_vmDo( 1 );
return (char *) hb_parc(-1);
}
else
return "";
}
static char * sz_callhrb_sz( char * szName, char * szParam1 )
{
PHB_DYNS pSym_onEvent = hb_dynsymFindName( szName );
if( pSym_onEvent )
{
hb_vmPushSymbol( hb_dynsymSymbol( pSym_onEvent ) );
hb_vmPushNil();
hb_vmPushString( szParam1, strlen( szParam1 ) );
hb_vmDo( 1 );
return (char *) hb_parc(-1);
}
else
return "";
}
PHB_ITEM hb_evalLaunch( PHB_EVALINFO pEvalInfo )
{
HB_THREAD_STUB
PHB_ITEM pResult = NULL;
HB_TRACE( HB_TR_DEBUG, ( "hb_evalLaunch(%p)", pEvalInfo ) );
if( pEvalInfo )
{
register USHORT uiParam = 1;
if( HB_IS_STRING( pEvalInfo->pItems[ 0 ] ) )
{
const char * ptr = pEvalInfo->pItems[ 0 ]->item.asString.value;
hb_vmPushSymbol( hb_dynsymFindName( ptr )->pSymbol );
hb_vmPushNil();
while( uiParam <= pEvalInfo->paramCount )
hb_vmPush( pEvalInfo->pItems[ uiParam++ ] );
hb_vmDo( pEvalInfo->paramCount );
pResult = hb_itemNew( NULL );
hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) );
}
else if( HB_IS_BLOCK( pEvalInfo->pItems[ 0 ] ) )
{
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pEvalInfo->pItems[ 0 ] );
while( uiParam <= pEvalInfo->paramCount )
hb_vmPush( pEvalInfo->pItems[ uiParam++ ] );
hb_vmSend( pEvalInfo->paramCount );
pResult = hb_itemNew( NULL );
hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) );
}
}
return pResult;
}
/* NOTE: Same as hb_itemDo(), but even simpler, since the function name can be
directly passed as a zero terminated string. [vszakats]
*/
PHB_ITEM hb_itemDoC( const char * szFunc, HB_SIZE ulPCount, ... )
{
HB_THREAD_STUB
PHB_ITEM pResult = NULL;
HB_TRACE( HB_TR_DEBUG, ( "hb_itemDoC(%s, %hu, ...)", szFunc, ulPCount ) );
if( szFunc )
{
PHB_DYNS pDynSym;
pDynSym = hb_dynsymFindName( szFunc );
if( pDynSym )
{
hb_vmPushState();
hb_vmPushSymbol( pDynSym->pSymbol );
hb_vmPushNil();
if( ulPCount )
{
register ULONG ulParam;
va_list va;
va_start( va, ulPCount );
for( ulParam = 1; ulParam <= ulPCount; ulParam++ )
hb_vmPush( va_arg( va, PHB_ITEM ) );
va_end( va );
}
hb_vmDo( ( USHORT ) ulPCount );
pResult = hb_itemNew( NULL );
hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) );
hb_vmPopState();
}
}
return pResult;
}
PHB_DYNS hb_dynsymFindName_r( const char * szName, PHB_DYNS pDest )
{
PHB_DYNS pRet;
hb_dynsymLock();
pRet = hb_dynsymFindName( szName );
if( pRet )
{
HB_MEMCPY( pDest, pRet, sizeof( HB_DYNS ) );
hb_dynsymUnlock();
return pDest;
}
hb_dynsymUnlock();
return NULL;
}
/*
* Find a WorkArea by the alias, return HB_FAILURE if not found
*/
HB_ERRCODE hb_rddGetAliasNumber( const char * szAlias, int * iArea )
{
HB_BOOL fOneLetter;
char c;
HB_TRACE( HB_TR_DEBUG, ( "hb_rddGetAliasNumber(%s, %p)", szAlias, iArea ) );
while( *szAlias == ' ' )
szAlias++;
c = szAlias[ 0 ];
if( c >= 'a' && c <= 'z' )
c -= 'a' - 'A';
fOneLetter = c && ( szAlias[ 1 ] == 0 || szAlias[ 1 ] == ' ' );
if( c >= '0' && c <= '9' )
{
*iArea = atoi( szAlias );
}
else if( fOneLetter && c >= 'A' && c <= 'K' )
{
*iArea = c - 'A' + 1;
}
else if( fOneLetter && c == 'M' )
{
*iArea = HB_RDD_MAX_AREA_NUM;
}
else
{
PHB_DYNS pSymAlias = hb_dynsymFindName( szAlias );
*iArea = pSymAlias ? ( int ) hb_dynsymAreaHandle( pSymAlias ) : 0;
if( *iArea == 0 )
return HB_FAILURE;
}
return HB_SUCCESS;
}
/*
* Retorna uma STRING de uma variavel caracter do xHarbour, criada via .PRG! Ela
* retorna em pulLen o tamanho da string encontrada.
* 01/07/2008 - 08:40:47
*/
char *wxMemvarGetCPtr( char * szVarName, ULONG *pulLen )
{
HB_THREAD_STUB
HB_DYNS_PTR pDynVar;
char *szValue = NULL;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetStrValuePtr(%s, %p)", szVarName, pulLen));
#ifdef HB_THREAD_SUPPORT
pDynVar = s_memvarThFindName( szVarName, &HB_VM_STACK );
#else
pDynVar = hb_dynsymFindName( szVarName );
#endif
if( pDynVar )
{
/* there is dynamic symbol with the requested name - check if it is
* a memvar variable
*/
if( pDynVar->hMemvar )
{
/* variable contains some data
*/
HB_ITEM_PTR pItem = hb_memvarGetValueByHandle( pDynVar->hMemvar );
if( HB_IS_BYREF( pItem ) )
{
pItem = hb_itemUnRef( pItem ); /* it is a PARAMETER variable */
}
if( HB_IS_STRING( pItem ) )
{
szValue = pItem->item.asString.value;
*pulLen = pItem->item.asString.length;
}
}
}
return szValue;
}
/*
* Retorna o valor LONG de uma variavel numérica do xHarbour, criada via .PRG
* 01/07/2008 - 08:40:47
*/
LONG wxMemvarGetNL( char * szVarName )
{
HB_THREAD_STUB
HB_DYNS_PTR pDynVar;
LONG result = 0;
HB_TRACE(HB_TR_DEBUG, ("hb_memvarGetStrValuePtr(%s, %p)", szVarName, pulLen));
#ifdef HB_THREAD_SUPPORT
pDynVar = s_memvarThFindName( szVarName, &HB_VM_STACK );
#else
pDynVar = hb_dynsymFindName( szVarName );
#endif
if( pDynVar )
{
/* there is dynamic symbol with the requested name - check if it is
* a memvar variable
*/
if( pDynVar->hMemvar )
{
/* variable contains some data
*/
HB_ITEM_PTR pItem = hb_memvarGetValueByHandle( pDynVar->hMemvar );
if( HB_IS_BYREF( pItem ) )
{
pItem = hb_itemUnRef( pItem ); /* it is a PARAMETER variable */
}
if( HB_IS_NUMERIC( pItem ) )
{
result = hb_itemGetNL( pItem );
}
}
}
return result;
}
static HRESULT STDMETHODCALLTYPE Invoke( IDispatch * lpThis, DISPID dispid, REFIID riid,
LCID lcid, WORD wFlags, DISPPARAMS * pParams,
VARIANT * pVarResult, EXCEPINFO * pExcepInfo,
UINT * puArgErr )
{
PHB_DYNS pDynSym;
PHB_ITEM pAction;
HB_USHORT uiClass = 0;
HB_SYMBOL_UNUSED( lcid );
HB_SYMBOL_UNUSED( pExcepInfo );
HB_SYMBOL_UNUSED( puArgErr );
if( ! IsEqualIID( riid, HB_ID_REF( IID_NULL ) ) )
return DISP_E_UNKNOWNINTERFACE;
pAction = ( ( IHbOleServer * ) lpThis )->pAction;
if( ! pAction )
pAction = s_pAction;
if( pAction )
{
HB_BOOL fResult = HB_FALSE;
if( s_pMsgHash )
{
if( ( wFlags & DISPATCH_METHOD ) != 0 ||
( ( wFlags & DISPATCH_PROPERTYGET ) != 0 && pParams->cArgs == 0 ) ||
( ( wFlags & DISPATCH_PROPERTYPUT ) != 0 && pParams->cArgs == 1 ) )
{
fResult = hb_oleDispInvoke( NULL, pAction,
hb_hashGetKeyAt( s_pMsgHash, ( HB_SIZE ) dispid ),
pParams, pVarResult, s_objItemToVariant, uiClass );
}
}
else if( HB_IS_HASH( pAction ) )
{
PHB_ITEM pItem;
if( ( ( IHbOleServer * ) lpThis )->fGuids )
{
PHB_ITEM pKey = hb_itemPutNL( hb_stackAllocItem(), ( long ) dispid );
pItem = hb_hashGetItemPtr( pAction, pKey, 0 );
hb_stackPop();
}
else
pItem = hb_hashGetValueAt( pAction, ( HB_SIZE ) dispid );
if( pItem )
{
if( HB_IS_EVALITEM( pItem ) )
{
if( ( wFlags & DISPATCH_METHOD ) != 0 )
{
PHB_SYMB pSym = hb_itemGetSymbol( pItem );
fResult = hb_oleDispInvoke( pSym, pSym ? pAction : pItem, NULL,
pParams, pVarResult,
s_objItemToVariant, uiClass );
}
}
else if( ( wFlags & DISPATCH_PROPERTYGET ) != 0 &&
pParams->cArgs == 0 )
{
if( pVarResult )
hb_oleItemToVariantEx( pVarResult, pItem, s_objItemToVariant );
fResult = HB_TRUE;
}
else if( ( wFlags & DISPATCH_PROPERTYPUT ) != 0 &&
pParams->cArgs == 1 )
{
hb_oleVariantToItemEx( pItem, &pParams->rgvarg[ 0 ], uiClass );
fResult = HB_TRUE;
}
}
}
else if( HB_IS_OBJECT( pAction ) )
{
pDynSym = hb_dispIdToDynsym( dispid );
if( pDynSym && ( wFlags & DISPATCH_PROPERTYPUT ) != 0 )
{
if( pParams->cArgs == 1 )
{
char szName[ HB_SYMBOL_NAME_LEN + 1 ];
szName[ 0 ] = '_';
hb_strncpy( szName + 1, hb_dynsymName( pDynSym ), sizeof( szName ) - 2 );
pDynSym = hb_dynsymFindName( szName );
}
else
pDynSym = NULL;
}
if( pDynSym && hb_objHasMessage( pAction, pDynSym ) )
{
fResult = hb_oleDispInvoke( hb_dynsymSymbol( pDynSym ),
pAction, NULL, pParams, pVarResult,
s_objItemToVariant, uiClass );
}
}
if( ! fResult )
return DISP_E_MEMBERNOTFOUND;
}
else
{
pDynSym = hb_dispIdToDynsym( dispid );
if( ! pDynSym )
return DISP_E_MEMBERNOTFOUND;
if( wFlags & DISPATCH_PROPERTYPUT )
{
if( pParams->cArgs == 1 && hb_dynsymIsMemvar( pDynSym ) )
{
PHB_ITEM pItem = hb_stackAllocItem();
hb_oleVariantToItemEx( pItem, &pParams->rgvarg[ 0 ], uiClass );
hb_memvarSetValue( hb_dynsymSymbol( pDynSym ), pItem );
hb_stackPop();
return S_OK;
}
else
return DISP_E_MEMBERNOTFOUND;
}
else if( ( wFlags & DISPATCH_PROPERTYGET ) &&
pParams->cArgs == 0 && hb_dynsymIsMemvar( pDynSym ) )
{
if( pVarResult )
{
PHB_ITEM pItem = hb_stackAllocItem();
hb_memvarGet( pItem, hb_dynsymSymbol( pDynSym ) );
hb_oleItemToVariantEx( pVarResult, pItem, s_objItemToVariant );
hb_stackPop();
}
return S_OK;
}
else if( ( wFlags & DISPATCH_METHOD ) == 0 ||
! hb_dynsymIsFunction( pDynSym ) )
return DISP_E_MEMBERNOTFOUND;
else if( ! hb_oleDispInvoke( hb_dynsymSymbol( pDynSym ),
NULL, NULL, pParams, pVarResult,
s_objItemToVariant, uiClass ) )
return DISP_E_MEMBERNOTFOUND;
}
return S_OK;
}
static HRESULT STDMETHODCALLTYPE GetIDsOfNames( IDispatch * lpThis, REFIID riid,
LPOLESTR * rgszNames,
UINT cNames, LCID lcid,
DISPID * rgDispId )
{
HRESULT hr = S_OK;
HB_SYMBOL_UNUSED( lcid );
if( ! IsEqualIID( riid, HB_ID_REF( IID_NULL ) ) )
hr = DISP_E_UNKNOWNINTERFACE;
else if( ( ( IHbOleServer * ) lpThis )->fGuids )
return E_NOTIMPL;
else if( cNames > 0 )
{
char szName[ HB_SYMBOL_NAME_LEN + 1 ];
DISPID dispid = 0;
UINT ui;
if( s_WideToAnsiBuffer( rgszNames[ 0 ], szName,
( int ) sizeof( szName ) ) != 0 )
{
PHB_ITEM pAction;
pAction = ( ( IHbOleServer * ) lpThis )->pAction;
if( ! pAction )
pAction = s_pAction;
if( pAction )
{
if( s_pMsgHash )
{
HB_SIZE nPos = hb_hashGetCItemPos( s_pMsgHash, szName );
if( nPos == 0 )
{
PHB_ITEM pKey = hb_itemPutC( hb_stackAllocItem(), szName );
if( hb_hashAdd( s_pMsgHash, pKey, NULL ) )
hb_hashScan( s_pMsgHash, pKey, &nPos );
hb_stackPop();
}
dispid = ( DISPID ) nPos;
}
else if( HB_IS_HASH( pAction ) )
{
HB_SIZE nPos = hb_hashGetCItemPos( pAction, szName );
if( nPos )
dispid = ( DISPID ) nPos;
}
else if( HB_IS_OBJECT( pAction ) )
{
PHB_DYNS pDynSym = hb_dynsymFindName( szName );
if( pDynSym && hb_objHasMessage( pAction, pDynSym ) )
dispid = hb_dynsymToDispId( pDynSym );
}
}
else
{
PHB_DYNS pDynSym = hb_dynsymFindName( szName );
if( pDynSym && ( hb_dynsymIsFunction( pDynSym ) ||
hb_dynsymIsMemvar( pDynSym ) ) )
dispid = hb_dynsymToDispId( pDynSym );
}
}
for( ui = 0; ui < cNames; ++ui )
rgDispId[ ui ] = DISPID_UNKNOWN;
hr = DISP_E_UNKNOWNNAME;
if( dispid )
{
rgDispId[ 0 ] = dispid;
if( cNames == 1 )
hr = S_OK;
}
}
return hr;
}
//------------------------------------------------------------------------------
// 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 );
}
/* NOTE: Same as hb_itemDoC(), but has additional second parameter
which set the reference mask for 1-st 32/64 parametes [druzus]
*/
PHB_ITEM hb_itemDoCRef( char * szFunc, HB_SIZE ulRefMask, HB_SIZE ulPCount, ... )
{
HB_THREAD_STUB
PHB_ITEM pResult = NULL;
HB_TRACE( HB_TR_DEBUG, ( "hb_itemDoCRef(%s, %hu, %hu, ...)", szFunc, ulRefMask, ulPCount ) );
if( szFunc )
{
PHB_DYNS pDynSym;
pDynSym = hb_dynsymFindName( szFunc );
if( pDynSym )
{
hb_vmPushState();
hb_vmPushSymbol( pDynSym->pSymbol );
hb_vmPushNil();
if( ulPCount )
{
PHB_ITEM pItemRefBuf[ sizeof( HB_SIZE ) * 8 ];
HB_ITEM itmRef;
register HB_SIZE ulParam;
HB_SIZE ulRef = 0;
va_list va;
PHB_ITEM * pRefBase;
PHB_ITEM pParam;
pRefBase = pItemRefBuf;
/* initialize the reference item */
itmRef.type = HB_IT_BYREF;
itmRef.item.asRefer.offset = -1;
itmRef.item.asRefer.BasePtr.itemsbasePtr = &pRefBase;
va_start( va, ulPCount );
for( ulParam = 0; ulParam < ulPCount; ulParam++ )
{
pParam = va_arg( va, PHB_ITEM );
if( ulRefMask & ( 1L << ulParam ) )
{
/* when item is passed by reference then we have to put
* the reference on the stack instead of the item itself
*/
pItemRefBuf[ ulRef++ ] = pParam;
itmRef.item.asRefer.value = ( LONG ) ulRef;
/* hb_vmPush( &itmRef ); */
pParam = &itmRef;
}
hb_vmPush( pParam );
}
va_end( va );
}
hb_vmDo( ( USHORT ) ulPCount );
pResult = hb_itemNew( NULL );
hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) );
hb_vmPopState();
}
}
return pResult;
}
PHB_ITEM hb_itemDo( PHB_ITEM pItem, HB_ULONG ulPCount, ... )
{
PHB_ITEM pResult = NULL;
HB_TRACE( HB_TR_DEBUG, ( "hb_itemDo(%p, %lu, ...)", pItem, ulPCount ) );
if( pItem )
{
PHB_SYMB pSymbol = NULL;
if( HB_IS_STRING( pItem ) )
{
PHB_DYNS pDynSym = hb_dynsymFindName( pItem->item.asString.value );
if( pDynSym )
{
pSymbol = pDynSym->pSymbol;
pItem = NULL;
}
}
else if( HB_IS_SYMBOL( pItem ) )
{
pSymbol = pItem->item.asSymbol.value;
pItem = NULL;
}
else if( HB_IS_BLOCK( pItem ) )
{
pSymbol = &hb_symEval;
}
if( pSymbol )
{
if( hb_vmRequestReenter() )
{
hb_vmPushSymbol( pSymbol );
if( pItem )
hb_vmPush( pItem );
else
hb_vmPushNil();
if( ulPCount )
{
HB_ULONG ulParam;
va_list va;
va_start( va, ulPCount );
for( ulParam = 1; ulParam <= ulPCount; ulParam++ )
hb_vmPush( va_arg( va, PHB_ITEM ) );
va_end( va );
}
if( pItem )
hb_vmSend( ( HB_USHORT ) ulPCount );
else
hb_vmProc( ( HB_USHORT ) ulPCount );
pResult = hb_itemNew( hb_stackReturnItem() );
hb_vmRequestRestore();
}
}
}
return pResult;
}
PHB_ITEM hb_itemDo( PHB_ITEM pItem, HB_SIZE ulPCount, ... )
{
HB_THREAD_STUB
PHB_ITEM pResult = NULL;
HB_TRACE( HB_TR_DEBUG, ( "hb_itemDo(%p, %hu, ...)", pItem, ulPCount ) );
if( pItem )
{
PHB_SYMB pSymbol = NULL;
if( HB_IS_STRING( pItem ) )
{
PHB_DYNS pDynSym = hb_dynsymFindName( pItem->item.asString.value );
if( pDynSym )
pSymbol = pDynSym->pSymbol;
}
else if( HB_IS_POINTER( pItem ) )
pSymbol = ( PHB_SYMB ) pItem->item.asPointer.value;
else if( HB_IS_SYMBOL( pItem ) )
pSymbol = pItem->item.asSymbol.value;
if( pSymbol )
{
hb_vmPushState();
hb_vmPushSymbol( pSymbol );
hb_vmPushNil();
if( ulPCount )
{
register ULONG ulParam;
va_list va;
va_start( va, ulPCount );
for( ulParam = 1; ulParam <= ulPCount; ulParam++ )
hb_vmPush( va_arg( va, PHB_ITEM ) );
va_end( va );
}
hb_vmDo( ( USHORT ) ulPCount );
pResult = hb_itemNew( NULL );
hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) );
hb_vmPopState();
}
else if( HB_IS_BLOCK( pItem ) )
{
hb_vmPushState();
hb_vmPushSymbol( &hb_symEval );
hb_vmPush( pItem );
if( ulPCount )
{
register ULONG ulParam;
va_list va;
va_start( va, ulPCount );
for( ulParam = 1; ulParam <= ulPCount; ulParam++ )
hb_vmPush( va_arg( va, PHB_ITEM ) );
va_end( va );
}
hb_vmSend( ( USHORT ) ulPCount );
pResult = hb_itemNew( NULL );
hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) );
hb_vmPopState();
}
else if( HB_IS_ARRAY( pItem ) )
{
hb_vmPushState();
if( hb_execFromArray( pItem ) )
{
pResult = hb_itemNew( NULL );
hb_itemForwardValue( pResult, &( HB_VM_STACK.Return ) );
}
hb_vmPopState();
}
}
return pResult;
}
BOOL hb_execFromArray( PHB_ITEM pFirst )
{
register ULONG i;
HB_SIZE ulLen;
ULONG ulStart = 1;
PHB_ITEM pArgs;
PHB_ITEM pString;
PHB_ITEM pSelf = NULL;
PHB_DYNS pExecSym = NULL;
PHB_SYMB pSymbol = NULL;
if( pFirst == NULL || pFirst->type != HB_IT_ARRAY )
return FALSE;
pString = hb_arrayGetItemPtr( pFirst, 1 );
pArgs = pFirst;
if( HB_IS_OBJECT( pString ) && hb_arrayLen( pFirst ) >= 2 )
{
pSelf = pString;
pString = hb_arrayGetItemPtr( pFirst, 2 );
if( pString->type == HB_IT_STRING )
pExecSym = hb_dynsymFindName( pString->item.asString.value );
else if( pString->type == HB_IT_POINTER )
pSymbol = ( PHB_SYMB ) hb_itemGetPtr( pString );
ulStart = 3;
}
else if( pString->type == HB_IT_STRING )
{
pExecSym = hb_dynsymFindName( pString->item.asString.value );
ulStart = 2;
}
else if( pString->type == HB_IT_POINTER )
{
pSymbol = ( PHB_SYMB ) hb_itemGetPtr( pString );
ulStart = 2;
}
else if( HB_IS_BLOCK( pString ) )
{
pSymbol = &hb_symEval;
ulStart = 2;
}
if( pExecSym )
pSymbol = pExecSym->pSymbol;
if( pSymbol == NULL )
return FALSE;
hb_vmPushSymbol( pSymbol );
if( pSelf )
hb_vmPush( pSelf );
else
hb_vmPushNil();
ulLen = hb_arrayLen( pArgs );
/* pushing the contents of the array
*/
for( i = ulStart; i <= ulLen; i++ )
hb_vmPush( hb_arrayGetItemPtr( pArgs, i ) );
if( pSelf )
hb_vmSend( ( USHORT ) ( ulLen - ulStart + 1 ) );
else
hb_vmDo( ( USHORT ) ( ulLen - ulStart + 1 ) );
return TRUE;
}
